namespace OpenTK.OpenGL
{
    using System;

    using GLsizei = System.Int32;
    using GLsizeiptr = System.IntPtr;
    using GLintptr = System.IntPtr;
    using GLboolean = System.Boolean;
    using GLbitfield = System.UInt32;
    using GLchar = System.Char;
    using GLbyte = System.SByte;
    using GLubyte = System.Byte;
    using GLshort = System.Int16;
    using GLushort = System.UInt16;
    using GLint = System.Int32;
    using GLuint = System.UInt32;
    using GLfloat = System.Single;
    using GLclampf = System.Single;
    using GLdouble = System.Double;
    using GLclampd = System.Double;
    using GLstring = System.String;
    using GLsizeiptrARB = System.IntPtr;
    using GLintptrARB = System.IntPtr;
    using GLhandleARB = System.UInt32;
    using GLhalfARB = System.UInt16;
    using GLhalfNV = System.UInt16;
    using GLcharARB = System.Char;
    using GLint64EXT = System.Int64;
    using GLuint64EXT = System.UInt64;
    using GLint64 = System.Int64;
    using GLuint64 = System.UInt64;

    public static partial class GL
    {
        static GL() { }

        public static 
        void NewList(Int32 list, GL.Enums.ListMode mode)
        {
            Delegates.glNewList((GLuint)list, (GL.Enums.ListMode)mode);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void NewList(GLuint list, GL.Enums.ListMode mode)
        {
            Delegates.glNewList((GLuint)list, (GL.Enums.ListMode)mode);
        }
        
        public static 
        void EndList()
        {
            Delegates.glEndList();
        }
        
        public static 
        void CallList(Int32 list)
        {
            Delegates.glCallList((GLuint)list);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void CallList(GLuint list)
        {
            Delegates.glCallList((GLuint)list);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void CallLists(GLsizei n, GL.Enums.ListNameType type, void* lists)
        {
            unsafe { Delegates.glCallLists((GLsizei)n, (GL.Enums.ListNameType)type, (void*)lists); }
        }
        
        public static 
        void CallLists(GLsizei n, GL.Enums.ListNameType type, object lists)
        {
            System.Runtime.InteropServices.GCHandle lists_ptr = System.Runtime.InteropServices.GCHandle.Alloc(lists, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glCallLists((GLsizei)n, (GL.Enums.ListNameType)type, (void*)lists_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    lists_ptr.Free();
                }
            }
        }
        
        public static 
        void DeleteLists(Int32 list, GLsizei range)
        {
            Delegates.glDeleteLists((GLuint)list, (GLsizei)range);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteLists(GLuint list, GLsizei range)
        {
            Delegates.glDeleteLists((GLuint)list, (GLsizei)range);
        }
        
        public static 
        Int32 GenLists(GLsizei range)
        {
            return Delegates.glGenLists((GLsizei)range);
        }
        
        public static 
        void ListBase(Int32 @base)
        {
            Delegates.glListBase((GLuint)@base);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void ListBase(GLuint @base)
        {
            Delegates.glListBase((GLuint)@base);
        }
        
        public static 
        void Begin(GL.Enums.BeginMode mode)
        {
            Delegates.glBegin((GL.Enums.BeginMode)mode);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte* bitmap)
        {
            unsafe { Delegates.glBitmap((GLsizei)width, (GLsizei)height, (GLfloat)xorig, (GLfloat)yorig, (GLfloat)xmove, (GLfloat)ymove, (GLubyte*)bitmap); }
        }
        
        public static 
        void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte[] bitmap)
        {
            unsafe
            {
                fixed (GLubyte* bitmap_ptr = bitmap)
                {
                    Delegates.glBitmap((GLsizei)width, (GLsizei)height, (GLfloat)xorig, (GLfloat)yorig, (GLfloat)xmove, (GLfloat)ymove, (GLubyte*)bitmap_ptr);
                }
            }
        }
        
        public static 
        void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, ref GLubyte bitmap)
        {
            unsafe
            {
                fixed (GLubyte* bitmap_ptr = &bitmap)
                {
                    Delegates.glBitmap((GLsizei)width, (GLsizei)height, (GLfloat)xorig, (GLfloat)yorig, (GLfloat)xmove, (GLfloat)ymove, (GLubyte*)bitmap_ptr);
                }
            }
        }
        
        public static 
        void Color3b(Byte red, Byte green, Byte blue)
        {
            Delegates.glColor3b((GLbyte)red, (GLbyte)green, (GLbyte)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3b(GLbyte red, GLbyte green, GLbyte blue)
        {
            Delegates.glColor3b((GLbyte)red, (GLbyte)green, (GLbyte)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3bv(Byte* v)
        {
                {
                    Delegates.glColor3bv((GLbyte*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3bv(GLbyte* v)
        {
            unsafe { Delegates.glColor3bv((GLbyte*)v); }
        }
        
        public static 
        void Color3bv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glColor3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3bv(GLbyte[] v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = v)
                {
                    Delegates.glColor3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3bv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glColor3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3bv(ref GLbyte v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = &v)
                {
                    Delegates.glColor3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3d(GLdouble red, GLdouble green, GLdouble blue)
        {
            Delegates.glColor3d((GLdouble)red, (GLdouble)green, (GLdouble)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3dv(GLdouble* v)
        {
            unsafe { Delegates.glColor3dv((GLdouble*)v); }
        }
        
        public static 
        void Color3dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glColor3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glColor3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3f(GLfloat red, GLfloat green, GLfloat blue)
        {
            Delegates.glColor3f((GLfloat)red, (GLfloat)green, (GLfloat)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3fv(GLfloat* v)
        {
            unsafe { Delegates.glColor3fv((GLfloat*)v); }
        }
        
        public static 
        void Color3fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glColor3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glColor3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3i(GLint red, GLint green, GLint blue)
        {
            Delegates.glColor3i((GLint)red, (GLint)green, (GLint)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3iv(GLint* v)
        {
            unsafe { Delegates.glColor3iv((GLint*)v); }
        }
        
        public static 
        void Color3iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glColor3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glColor3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3s(GLshort red, GLshort green, GLshort blue)
        {
            Delegates.glColor3s((GLshort)red, (GLshort)green, (GLshort)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3sv(GLshort* v)
        {
            unsafe { Delegates.glColor3sv((GLshort*)v); }
        }
        
        public static 
        void Color3sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glColor3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glColor3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3ub(GLubyte red, GLubyte green, GLubyte blue)
        {
            Delegates.glColor3ub((GLubyte)red, (GLubyte)green, (GLubyte)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3ubv(GLubyte* v)
        {
            unsafe { Delegates.glColor3ubv((GLubyte*)v); }
        }
        
        public static 
        void Color3ubv(GLubyte[] v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = v)
                {
                    Delegates.glColor3ubv((GLubyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3ubv(ref GLubyte v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = &v)
                {
                    Delegates.glColor3ubv((GLubyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3ui(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glColor3ui((GLuint)red, (GLuint)green, (GLuint)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3ui(GLuint red, GLuint green, GLuint blue)
        {
            Delegates.glColor3ui((GLuint)red, (GLuint)green, (GLuint)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3uiv(Int32* v)
        {
                {
                    Delegates.glColor3uiv((GLuint*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3uiv(GLuint* v)
        {
            unsafe { Delegates.glColor3uiv((GLuint*)v); }
        }
        
        public static 
        void Color3uiv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glColor3uiv((GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3uiv(GLuint[] v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = v)
                {
                    Delegates.glColor3uiv((GLuint*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3uiv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glColor3uiv((GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3uiv(ref GLuint v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = &v)
                {
                    Delegates.glColor3uiv((GLuint*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3us(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glColor3us((GLushort)red, (GLushort)green, (GLushort)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3us(GLushort red, GLushort green, GLushort blue)
        {
            Delegates.glColor3us((GLushort)red, (GLushort)green, (GLushort)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3usv(Int16* v)
        {
                {
                    Delegates.glColor3usv((GLushort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3usv(GLushort* v)
        {
            unsafe { Delegates.glColor3usv((GLushort*)v); }
        }
        
        public static 
        void Color3usv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor3usv((GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3usv(GLushort[] v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = v)
                {
                    Delegates.glColor3usv((GLushort*)v_ptr);
                }
            }
        }
        
        public static 
        void Color3usv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor3usv((GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color3usv(ref GLushort v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = &v)
                {
                    Delegates.glColor3usv((GLushort*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4b(Byte red, Byte green, Byte blue, Byte alpha)
        {
            Delegates.glColor4b((GLbyte)red, (GLbyte)green, (GLbyte)blue, (GLbyte)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
        {
            Delegates.glColor4b((GLbyte)red, (GLbyte)green, (GLbyte)blue, (GLbyte)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4bv(Byte* v)
        {
                {
                    Delegates.glColor4bv((GLbyte*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4bv(GLbyte* v)
        {
            unsafe { Delegates.glColor4bv((GLbyte*)v); }
        }
        
        public static 
        void Color4bv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glColor4bv((GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4bv(GLbyte[] v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = v)
                {
                    Delegates.glColor4bv((GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4bv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glColor4bv((GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4bv(ref GLbyte v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = &v)
                {
                    Delegates.glColor4bv((GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
        {
            Delegates.glColor4d((GLdouble)red, (GLdouble)green, (GLdouble)blue, (GLdouble)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4dv(GLdouble* v)
        {
            unsafe { Delegates.glColor4dv((GLdouble*)v); }
        }
        
        public static 
        void Color4dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glColor4dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glColor4dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
        {
            Delegates.glColor4f((GLfloat)red, (GLfloat)green, (GLfloat)blue, (GLfloat)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4fv(GLfloat* v)
        {
            unsafe { Delegates.glColor4fv((GLfloat*)v); }
        }
        
        public static 
        void Color4fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glColor4fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glColor4fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4i(GLint red, GLint green, GLint blue, GLint alpha)
        {
            Delegates.glColor4i((GLint)red, (GLint)green, (GLint)blue, (GLint)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4iv(GLint* v)
        {
            unsafe { Delegates.glColor4iv((GLint*)v); }
        }
        
        public static 
        void Color4iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glColor4iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glColor4iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
        {
            Delegates.glColor4s((GLshort)red, (GLshort)green, (GLshort)blue, (GLshort)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4sv(GLshort* v)
        {
            unsafe { Delegates.glColor4sv((GLshort*)v); }
        }
        
        public static 
        void Color4sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glColor4sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glColor4sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
        {
            Delegates.glColor4ub((GLubyte)red, (GLubyte)green, (GLubyte)blue, (GLubyte)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4ubv(GLubyte* v)
        {
            unsafe { Delegates.glColor4ubv((GLubyte*)v); }
        }
        
        public static 
        void Color4ubv(GLubyte[] v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = v)
                {
                    Delegates.glColor4ubv((GLubyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4ubv(ref GLubyte v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = &v)
                {
                    Delegates.glColor4ubv((GLubyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4ui(Int32 red, Int32 green, Int32 blue, Int32 alpha)
        {
            Delegates.glColor4ui((GLuint)red, (GLuint)green, (GLuint)blue, (GLuint)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
        {
            Delegates.glColor4ui((GLuint)red, (GLuint)green, (GLuint)blue, (GLuint)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4uiv(Int32* v)
        {
                {
                    Delegates.glColor4uiv((GLuint*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4uiv(GLuint* v)
        {
            unsafe { Delegates.glColor4uiv((GLuint*)v); }
        }
        
        public static 
        void Color4uiv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glColor4uiv((GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4uiv(GLuint[] v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = v)
                {
                    Delegates.glColor4uiv((GLuint*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4uiv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glColor4uiv((GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4uiv(ref GLuint v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = &v)
                {
                    Delegates.glColor4uiv((GLuint*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4us(Int16 red, Int16 green, Int16 blue, Int16 alpha)
        {
            Delegates.glColor4us((GLushort)red, (GLushort)green, (GLushort)blue, (GLushort)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
        {
            Delegates.glColor4us((GLushort)red, (GLushort)green, (GLushort)blue, (GLushort)alpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4usv(Int16* v)
        {
                {
                    Delegates.glColor4usv((GLushort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4usv(GLushort* v)
        {
            unsafe { Delegates.glColor4usv((GLushort*)v); }
        }
        
        public static 
        void Color4usv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor4usv((GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4usv(GLushort[] v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = v)
                {
                    Delegates.glColor4usv((GLushort*)v_ptr);
                }
            }
        }
        
        public static 
        void Color4usv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor4usv((GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Color4usv(ref GLushort v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = &v)
                {
                    Delegates.glColor4usv((GLushort*)v_ptr);
                }
            }
        }
        
        public static 
        void EdgeFlag(GL.Enums.Boolean flag)
        {
             Delegates.glEdgeFlag((GL.Enums.Boolean)flag); 
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void EdgeFlagv(GL.Enums.Boolean* flag)
        {
            unsafe { Delegates.glEdgeFlagv((GL.Enums.Boolean*)flag); }
        }
        
        public static 
        void End()
        {
            Delegates.glEnd();
        }
        
        public static 
        void Indexd(GLdouble c)
        {
            Delegates.glIndexd((GLdouble)c);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexdv(GLdouble* c)
        {
            unsafe { Delegates.glIndexdv((GLdouble*)c); }
        }
        
        public static 
        void Indexdv(GLdouble[] c)
        {
            unsafe
            {
                fixed (GLdouble* c_ptr = c)
                {
                    Delegates.glIndexdv((GLdouble*)c_ptr);
                }
            }
        }
        
        public static 
        void Indexdv(ref GLdouble c)
        {
            unsafe
            {
                fixed (GLdouble* c_ptr = &c)
                {
                    Delegates.glIndexdv((GLdouble*)c_ptr);
                }
            }
        }
        
        public static 
        void Indexf(GLfloat c)
        {
            Delegates.glIndexf((GLfloat)c);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexfv(GLfloat* c)
        {
            unsafe { Delegates.glIndexfv((GLfloat*)c); }
        }
        
        public static 
        void Indexfv(GLfloat[] c)
        {
            unsafe
            {
                fixed (GLfloat* c_ptr = c)
                {
                    Delegates.glIndexfv((GLfloat*)c_ptr);
                }
            }
        }
        
        public static 
        void Indexfv(ref GLfloat c)
        {
            unsafe
            {
                fixed (GLfloat* c_ptr = &c)
                {
                    Delegates.glIndexfv((GLfloat*)c_ptr);
                }
            }
        }
        
        public static 
        void Indexi(GLint c)
        {
            Delegates.glIndexi((GLint)c);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexiv(GLint* c)
        {
            unsafe { Delegates.glIndexiv((GLint*)c); }
        }
        
        public static 
        void Indexiv(GLint[] c)
        {
            unsafe
            {
                fixed (GLint* c_ptr = c)
                {
                    Delegates.glIndexiv((GLint*)c_ptr);
                }
            }
        }
        
        public static 
        void Indexiv(ref GLint c)
        {
            unsafe
            {
                fixed (GLint* c_ptr = &c)
                {
                    Delegates.glIndexiv((GLint*)c_ptr);
                }
            }
        }
        
        public static 
        void Indexs(GLshort c)
        {
            Delegates.glIndexs((GLshort)c);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexsv(GLshort* c)
        {
            unsafe { Delegates.glIndexsv((GLshort*)c); }
        }
        
        public static 
        void Indexsv(GLshort[] c)
        {
            unsafe
            {
                fixed (GLshort* c_ptr = c)
                {
                    Delegates.glIndexsv((GLshort*)c_ptr);
                }
            }
        }
        
        public static 
        void Indexsv(ref GLshort c)
        {
            unsafe
            {
                fixed (GLshort* c_ptr = &c)
                {
                    Delegates.glIndexsv((GLshort*)c_ptr);
                }
            }
        }
        
        public static 
        void Normal3b(Byte nx, Byte ny, Byte nz)
        {
            Delegates.glNormal3b((GLbyte)nx, (GLbyte)ny, (GLbyte)nz);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
        {
            Delegates.glNormal3b((GLbyte)nx, (GLbyte)ny, (GLbyte)nz);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3bv(Byte* v)
        {
                {
                    Delegates.glNormal3bv((GLbyte*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3bv(GLbyte* v)
        {
            unsafe { Delegates.glNormal3bv((GLbyte*)v); }
        }
        
        public static 
        void Normal3bv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glNormal3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Normal3bv(GLbyte[] v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = v)
                {
                    Delegates.glNormal3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3bv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glNormal3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void Normal3bv(ref GLbyte v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = &v)
                {
                    Delegates.glNormal3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
        {
            Delegates.glNormal3d((GLdouble)nx, (GLdouble)ny, (GLdouble)nz);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3dv(GLdouble* v)
        {
            unsafe { Delegates.glNormal3dv((GLdouble*)v); }
        }
        
        public static 
        void Normal3dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glNormal3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glNormal3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3f(GLfloat nx, GLfloat ny, GLfloat nz)
        {
            Delegates.glNormal3f((GLfloat)nx, (GLfloat)ny, (GLfloat)nz);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3fv(GLfloat* v)
        {
            unsafe { Delegates.glNormal3fv((GLfloat*)v); }
        }
        
        public static 
        void Normal3fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glNormal3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glNormal3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3i(GLint nx, GLint ny, GLint nz)
        {
            Delegates.glNormal3i((GLint)nx, (GLint)ny, (GLint)nz);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3iv(GLint* v)
        {
            unsafe { Delegates.glNormal3iv((GLint*)v); }
        }
        
        public static 
        void Normal3iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glNormal3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glNormal3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3s(GLshort nx, GLshort ny, GLshort nz)
        {
            Delegates.glNormal3s((GLshort)nx, (GLshort)ny, (GLshort)nz);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3sv(GLshort* v)
        {
            unsafe { Delegates.glNormal3sv((GLshort*)v); }
        }
        
        public static 
        void Normal3sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glNormal3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Normal3sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glNormal3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos2d(GLdouble x, GLdouble y)
        {
            Delegates.glRasterPos2d((GLdouble)x, (GLdouble)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos2dv(GLdouble* v)
        {
            unsafe { Delegates.glRasterPos2dv((GLdouble*)v); }
        }
        
        public static 
        void RasterPos2dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glRasterPos2dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos2dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glRasterPos2dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos2f(GLfloat x, GLfloat y)
        {
            Delegates.glRasterPos2f((GLfloat)x, (GLfloat)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos2fv(GLfloat* v)
        {
            unsafe { Delegates.glRasterPos2fv((GLfloat*)v); }
        }
        
        public static 
        void RasterPos2fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glRasterPos2fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos2fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glRasterPos2fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos2i(GLint x, GLint y)
        {
            Delegates.glRasterPos2i((GLint)x, (GLint)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos2iv(GLint* v)
        {
            unsafe { Delegates.glRasterPos2iv((GLint*)v); }
        }
        
        public static 
        void RasterPos2iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glRasterPos2iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos2iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glRasterPos2iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos2s(GLshort x, GLshort y)
        {
            Delegates.glRasterPos2s((GLshort)x, (GLshort)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos2sv(GLshort* v)
        {
            unsafe { Delegates.glRasterPos2sv((GLshort*)v); }
        }
        
        public static 
        void RasterPos2sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glRasterPos2sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos2sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glRasterPos2sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
        {
            Delegates.glRasterPos3d((GLdouble)x, (GLdouble)y, (GLdouble)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos3dv(GLdouble* v)
        {
            unsafe { Delegates.glRasterPos3dv((GLdouble*)v); }
        }
        
        public static 
        void RasterPos3dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glRasterPos3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos3dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glRasterPos3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
        {
            Delegates.glRasterPos3f((GLfloat)x, (GLfloat)y, (GLfloat)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos3fv(GLfloat* v)
        {
            unsafe { Delegates.glRasterPos3fv((GLfloat*)v); }
        }
        
        public static 
        void RasterPos3fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glRasterPos3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos3fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glRasterPos3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos3i(GLint x, GLint y, GLint z)
        {
            Delegates.glRasterPos3i((GLint)x, (GLint)y, (GLint)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos3iv(GLint* v)
        {
            unsafe { Delegates.glRasterPos3iv((GLint*)v); }
        }
        
        public static 
        void RasterPos3iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glRasterPos3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos3iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glRasterPos3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos3s(GLshort x, GLshort y, GLshort z)
        {
            Delegates.glRasterPos3s((GLshort)x, (GLshort)y, (GLshort)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos3sv(GLshort* v)
        {
            unsafe { Delegates.glRasterPos3sv((GLshort*)v); }
        }
        
        public static 
        void RasterPos3sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glRasterPos3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos3sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glRasterPos3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
        {
            Delegates.glRasterPos4d((GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos4dv(GLdouble* v)
        {
            unsafe { Delegates.glRasterPos4dv((GLdouble*)v); }
        }
        
        public static 
        void RasterPos4dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glRasterPos4dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos4dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glRasterPos4dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
        {
            Delegates.glRasterPos4f((GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos4fv(GLfloat* v)
        {
            unsafe { Delegates.glRasterPos4fv((GLfloat*)v); }
        }
        
        public static 
        void RasterPos4fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glRasterPos4fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos4fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glRasterPos4fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos4i(GLint x, GLint y, GLint z, GLint w)
        {
            Delegates.glRasterPos4i((GLint)x, (GLint)y, (GLint)z, (GLint)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos4iv(GLint* v)
        {
            unsafe { Delegates.glRasterPos4iv((GLint*)v); }
        }
        
        public static 
        void RasterPos4iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glRasterPos4iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos4iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glRasterPos4iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
        {
            Delegates.glRasterPos4s((GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos4sv(GLshort* v)
        {
            unsafe { Delegates.glRasterPos4sv((GLshort*)v); }
        }
        
        public static 
        void RasterPos4sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glRasterPos4sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void RasterPos4sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glRasterPos4sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
        {
            Delegates.glRectd((GLdouble)x1, (GLdouble)y1, (GLdouble)x2, (GLdouble)y2);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectdv(GLdouble* v1, GLdouble* v2)
        {
            unsafe { Delegates.glRectdv((GLdouble*)v1, (GLdouble*)v2); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectdv(GLdouble* v1, GLdouble[] v2)
        {
                fixed (GLdouble* v2_ptr = v2)
                {
                    Delegates.glRectdv((GLdouble*)v1, (GLdouble*)v2_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectdv(GLdouble* v1, ref GLdouble v2)
        {
                fixed (GLdouble* v2_ptr = &v2)
                {
                    Delegates.glRectdv((GLdouble*)v1, (GLdouble*)v2_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectdv(GLdouble[] v1, GLdouble* v2)
        {
                fixed (GLdouble* v1_ptr = v1)
                {
                    Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2);
                }
        }
        
        public static 
        void Rectdv(GLdouble[] v1, GLdouble[] v2)
        {
            unsafe
            {
                fixed (GLdouble* v1_ptr = v1)
                fixed (GLdouble* v2_ptr = v2)
                {
                    Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectdv(GLdouble[] v1, ref GLdouble v2)
        {
            unsafe
            {
                fixed (GLdouble* v1_ptr = v1)
                fixed (GLdouble* v2_ptr = &v2)
                {
                    Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectdv(ref GLdouble v1, GLdouble* v2)
        {
                fixed (GLdouble* v1_ptr = &v1)
                {
                    Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2);
                }
        }
        
        public static 
        void Rectdv(ref GLdouble v1, GLdouble[] v2)
        {
            unsafe
            {
                fixed (GLdouble* v1_ptr = &v1)
                fixed (GLdouble* v2_ptr = v2)
                {
                    Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectdv(ref GLdouble v1, ref GLdouble v2)
        {
            unsafe
            {
                fixed (GLdouble* v1_ptr = &v1)
                fixed (GLdouble* v2_ptr = &v2)
                {
                    Delegates.glRectdv((GLdouble*)v1_ptr, (GLdouble*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
        {
            Delegates.glRectf((GLfloat)x1, (GLfloat)y1, (GLfloat)x2, (GLfloat)y2);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectfv(GLfloat* v1, GLfloat* v2)
        {
            unsafe { Delegates.glRectfv((GLfloat*)v1, (GLfloat*)v2); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectfv(GLfloat* v1, GLfloat[] v2)
        {
                fixed (GLfloat* v2_ptr = v2)
                {
                    Delegates.glRectfv((GLfloat*)v1, (GLfloat*)v2_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectfv(GLfloat* v1, ref GLfloat v2)
        {
                fixed (GLfloat* v2_ptr = &v2)
                {
                    Delegates.glRectfv((GLfloat*)v1, (GLfloat*)v2_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectfv(GLfloat[] v1, GLfloat* v2)
        {
                fixed (GLfloat* v1_ptr = v1)
                {
                    Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2);
                }
        }
        
        public static 
        void Rectfv(GLfloat[] v1, GLfloat[] v2)
        {
            unsafe
            {
                fixed (GLfloat* v1_ptr = v1)
                fixed (GLfloat* v2_ptr = v2)
                {
                    Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectfv(GLfloat[] v1, ref GLfloat v2)
        {
            unsafe
            {
                fixed (GLfloat* v1_ptr = v1)
                fixed (GLfloat* v2_ptr = &v2)
                {
                    Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectfv(ref GLfloat v1, GLfloat* v2)
        {
                fixed (GLfloat* v1_ptr = &v1)
                {
                    Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2);
                }
        }
        
        public static 
        void Rectfv(ref GLfloat v1, GLfloat[] v2)
        {
            unsafe
            {
                fixed (GLfloat* v1_ptr = &v1)
                fixed (GLfloat* v2_ptr = v2)
                {
                    Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectfv(ref GLfloat v1, ref GLfloat v2)
        {
            unsafe
            {
                fixed (GLfloat* v1_ptr = &v1)
                fixed (GLfloat* v2_ptr = &v2)
                {
                    Delegates.glRectfv((GLfloat*)v1_ptr, (GLfloat*)v2_ptr);
                }
            }
        }
        
        public static 
        void Recti(GLint x1, GLint y1, GLint x2, GLint y2)
        {
            Delegates.glRecti((GLint)x1, (GLint)y1, (GLint)x2, (GLint)y2);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectiv(GLint* v1, GLint* v2)
        {
            unsafe { Delegates.glRectiv((GLint*)v1, (GLint*)v2); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectiv(GLint* v1, GLint[] v2)
        {
                fixed (GLint* v2_ptr = v2)
                {
                    Delegates.glRectiv((GLint*)v1, (GLint*)v2_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectiv(GLint* v1, ref GLint v2)
        {
                fixed (GLint* v2_ptr = &v2)
                {
                    Delegates.glRectiv((GLint*)v1, (GLint*)v2_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectiv(GLint[] v1, GLint* v2)
        {
                fixed (GLint* v1_ptr = v1)
                {
                    Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2);
                }
        }
        
        public static 
        void Rectiv(GLint[] v1, GLint[] v2)
        {
            unsafe
            {
                fixed (GLint* v1_ptr = v1)
                fixed (GLint* v2_ptr = v2)
                {
                    Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectiv(GLint[] v1, ref GLint v2)
        {
            unsafe
            {
                fixed (GLint* v1_ptr = v1)
                fixed (GLint* v2_ptr = &v2)
                {
                    Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectiv(ref GLint v1, GLint* v2)
        {
                fixed (GLint* v1_ptr = &v1)
                {
                    Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2);
                }
        }
        
        public static 
        void Rectiv(ref GLint v1, GLint[] v2)
        {
            unsafe
            {
                fixed (GLint* v1_ptr = &v1)
                fixed (GLint* v2_ptr = v2)
                {
                    Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectiv(ref GLint v1, ref GLint v2)
        {
            unsafe
            {
                fixed (GLint* v1_ptr = &v1)
                fixed (GLint* v2_ptr = &v2)
                {
                    Delegates.glRectiv((GLint*)v1_ptr, (GLint*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
        {
            Delegates.glRects((GLshort)x1, (GLshort)y1, (GLshort)x2, (GLshort)y2);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectsv(GLshort* v1, GLshort* v2)
        {
            unsafe { Delegates.glRectsv((GLshort*)v1, (GLshort*)v2); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectsv(GLshort* v1, GLshort[] v2)
        {
                fixed (GLshort* v2_ptr = v2)
                {
                    Delegates.glRectsv((GLshort*)v1, (GLshort*)v2_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectsv(GLshort* v1, ref GLshort v2)
        {
                fixed (GLshort* v2_ptr = &v2)
                {
                    Delegates.glRectsv((GLshort*)v1, (GLshort*)v2_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectsv(GLshort[] v1, GLshort* v2)
        {
                fixed (GLshort* v1_ptr = v1)
                {
                    Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2);
                }
        }
        
        public static 
        void Rectsv(GLshort[] v1, GLshort[] v2)
        {
            unsafe
            {
                fixed (GLshort* v1_ptr = v1)
                fixed (GLshort* v2_ptr = v2)
                {
                    Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectsv(GLshort[] v1, ref GLshort v2)
        {
            unsafe
            {
                fixed (GLshort* v1_ptr = v1)
                fixed (GLshort* v2_ptr = &v2)
                {
                    Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Rectsv(ref GLshort v1, GLshort* v2)
        {
                fixed (GLshort* v1_ptr = &v1)
                {
                    Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2);
                }
        }
        
        public static 
        void Rectsv(ref GLshort v1, GLshort[] v2)
        {
            unsafe
            {
                fixed (GLshort* v1_ptr = &v1)
                fixed (GLshort* v2_ptr = v2)
                {
                    Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2_ptr);
                }
            }
        }
        
        public static 
        void Rectsv(ref GLshort v1, ref GLshort v2)
        {
            unsafe
            {
                fixed (GLshort* v1_ptr = &v1)
                fixed (GLshort* v2_ptr = &v2)
                {
                    Delegates.glRectsv((GLshort*)v1_ptr, (GLshort*)v2_ptr);
                }
            }
        }
        
        public static 
        void TexCoord1d(GLdouble s)
        {
            Delegates.glTexCoord1d((GLdouble)s);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord1dv(GLdouble* v)
        {
            unsafe { Delegates.glTexCoord1dv((GLdouble*)v); }
        }
        
        public static 
        void TexCoord1dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glTexCoord1dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord1dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glTexCoord1dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord1f(GLfloat s)
        {
            Delegates.glTexCoord1f((GLfloat)s);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord1fv(GLfloat* v)
        {
            unsafe { Delegates.glTexCoord1fv((GLfloat*)v); }
        }
        
        public static 
        void TexCoord1fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glTexCoord1fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord1fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glTexCoord1fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord1i(GLint s)
        {
            Delegates.glTexCoord1i((GLint)s);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord1iv(GLint* v)
        {
            unsafe { Delegates.glTexCoord1iv((GLint*)v); }
        }
        
        public static 
        void TexCoord1iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glTexCoord1iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord1iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glTexCoord1iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord1s(GLshort s)
        {
            Delegates.glTexCoord1s((GLshort)s);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord1sv(GLshort* v)
        {
            unsafe { Delegates.glTexCoord1sv((GLshort*)v); }
        }
        
        public static 
        void TexCoord1sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glTexCoord1sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord1sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glTexCoord1sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord2d(GLdouble s, GLdouble t)
        {
            Delegates.glTexCoord2d((GLdouble)s, (GLdouble)t);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord2dv(GLdouble* v)
        {
            unsafe { Delegates.glTexCoord2dv((GLdouble*)v); }
        }
        
        public static 
        void TexCoord2dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glTexCoord2dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord2dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glTexCoord2dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord2f(GLfloat s, GLfloat t)
        {
            Delegates.glTexCoord2f((GLfloat)s, (GLfloat)t);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord2fv(GLfloat* v)
        {
            unsafe { Delegates.glTexCoord2fv((GLfloat*)v); }
        }
        
        public static 
        void TexCoord2fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glTexCoord2fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord2fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glTexCoord2fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord2i(GLint s, GLint t)
        {
            Delegates.glTexCoord2i((GLint)s, (GLint)t);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord2iv(GLint* v)
        {
            unsafe { Delegates.glTexCoord2iv((GLint*)v); }
        }
        
        public static 
        void TexCoord2iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glTexCoord2iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord2iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glTexCoord2iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord2s(GLshort s, GLshort t)
        {
            Delegates.glTexCoord2s((GLshort)s, (GLshort)t);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord2sv(GLshort* v)
        {
            unsafe { Delegates.glTexCoord2sv((GLshort*)v); }
        }
        
        public static 
        void TexCoord2sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glTexCoord2sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord2sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glTexCoord2sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord3d(GLdouble s, GLdouble t, GLdouble r)
        {
            Delegates.glTexCoord3d((GLdouble)s, (GLdouble)t, (GLdouble)r);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord3dv(GLdouble* v)
        {
            unsafe { Delegates.glTexCoord3dv((GLdouble*)v); }
        }
        
        public static 
        void TexCoord3dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glTexCoord3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord3dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glTexCoord3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
        {
            Delegates.glTexCoord3f((GLfloat)s, (GLfloat)t, (GLfloat)r);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord3fv(GLfloat* v)
        {
            unsafe { Delegates.glTexCoord3fv((GLfloat*)v); }
        }
        
        public static 
        void TexCoord3fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glTexCoord3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord3fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glTexCoord3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord3i(GLint s, GLint t, GLint r)
        {
            Delegates.glTexCoord3i((GLint)s, (GLint)t, (GLint)r);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord3iv(GLint* v)
        {
            unsafe { Delegates.glTexCoord3iv((GLint*)v); }
        }
        
        public static 
        void TexCoord3iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glTexCoord3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord3iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glTexCoord3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord3s(GLshort s, GLshort t, GLshort r)
        {
            Delegates.glTexCoord3s((GLshort)s, (GLshort)t, (GLshort)r);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord3sv(GLshort* v)
        {
            unsafe { Delegates.glTexCoord3sv((GLshort*)v); }
        }
        
        public static 
        void TexCoord3sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glTexCoord3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord3sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glTexCoord3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
        {
            Delegates.glTexCoord4d((GLdouble)s, (GLdouble)t, (GLdouble)r, (GLdouble)q);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord4dv(GLdouble* v)
        {
            unsafe { Delegates.glTexCoord4dv((GLdouble*)v); }
        }
        
        public static 
        void TexCoord4dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glTexCoord4dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord4dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glTexCoord4dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
        {
            Delegates.glTexCoord4f((GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)q);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord4fv(GLfloat* v)
        {
            unsafe { Delegates.glTexCoord4fv((GLfloat*)v); }
        }
        
        public static 
        void TexCoord4fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glTexCoord4fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord4fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glTexCoord4fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord4i(GLint s, GLint t, GLint r, GLint q)
        {
            Delegates.glTexCoord4i((GLint)s, (GLint)t, (GLint)r, (GLint)q);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord4iv(GLint* v)
        {
            unsafe { Delegates.glTexCoord4iv((GLint*)v); }
        }
        
        public static 
        void TexCoord4iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glTexCoord4iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord4iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glTexCoord4iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
        {
            Delegates.glTexCoord4s((GLshort)s, (GLshort)t, (GLshort)r, (GLshort)q);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord4sv(GLshort* v)
        {
            unsafe { Delegates.glTexCoord4sv((GLshort*)v); }
        }
        
        public static 
        void TexCoord4sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glTexCoord4sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void TexCoord4sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glTexCoord4sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex2d(GLdouble x, GLdouble y)
        {
            Delegates.glVertex2d((GLdouble)x, (GLdouble)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex2dv(GLdouble* v)
        {
            unsafe { Delegates.glVertex2dv((GLdouble*)v); }
        }
        
        public static 
        void Vertex2dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertex2dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex2dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertex2dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex2f(GLfloat x, GLfloat y)
        {
            Delegates.glVertex2f((GLfloat)x, (GLfloat)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex2fv(GLfloat* v)
        {
            unsafe { Delegates.glVertex2fv((GLfloat*)v); }
        }
        
        public static 
        void Vertex2fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertex2fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex2fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertex2fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex2i(GLint x, GLint y)
        {
            Delegates.glVertex2i((GLint)x, (GLint)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex2iv(GLint* v)
        {
            unsafe { Delegates.glVertex2iv((GLint*)v); }
        }
        
        public static 
        void Vertex2iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glVertex2iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex2iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glVertex2iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex2s(GLshort x, GLshort y)
        {
            Delegates.glVertex2s((GLshort)x, (GLshort)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex2sv(GLshort* v)
        {
            unsafe { Delegates.glVertex2sv((GLshort*)v); }
        }
        
        public static 
        void Vertex2sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertex2sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex2sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertex2sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex3d(GLdouble x, GLdouble y, GLdouble z)
        {
            Delegates.glVertex3d((GLdouble)x, (GLdouble)y, (GLdouble)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex3dv(GLdouble* v)
        {
            unsafe { Delegates.glVertex3dv((GLdouble*)v); }
        }
        
        public static 
        void Vertex3dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertex3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex3dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertex3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex3f(GLfloat x, GLfloat y, GLfloat z)
        {
            Delegates.glVertex3f((GLfloat)x, (GLfloat)y, (GLfloat)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex3fv(GLfloat* v)
        {
            unsafe { Delegates.glVertex3fv((GLfloat*)v); }
        }
        
        public static 
        void Vertex3fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertex3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex3fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertex3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex3i(GLint x, GLint y, GLint z)
        {
            Delegates.glVertex3i((GLint)x, (GLint)y, (GLint)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex3iv(GLint* v)
        {
            unsafe { Delegates.glVertex3iv((GLint*)v); }
        }
        
        public static 
        void Vertex3iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glVertex3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex3iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glVertex3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex3s(GLshort x, GLshort y, GLshort z)
        {
            Delegates.glVertex3s((GLshort)x, (GLshort)y, (GLshort)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex3sv(GLshort* v)
        {
            unsafe { Delegates.glVertex3sv((GLshort*)v); }
        }
        
        public static 
        void Vertex3sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertex3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex3sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertex3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
        {
            Delegates.glVertex4d((GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex4dv(GLdouble* v)
        {
            unsafe { Delegates.glVertex4dv((GLdouble*)v); }
        }
        
        public static 
        void Vertex4dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertex4dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex4dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertex4dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
        {
            Delegates.glVertex4f((GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex4fv(GLfloat* v)
        {
            unsafe { Delegates.glVertex4fv((GLfloat*)v); }
        }
        
        public static 
        void Vertex4fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertex4fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex4fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertex4fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex4i(GLint x, GLint y, GLint z, GLint w)
        {
            Delegates.glVertex4i((GLint)x, (GLint)y, (GLint)z, (GLint)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex4iv(GLint* v)
        {
            unsafe { Delegates.glVertex4iv((GLint*)v); }
        }
        
        public static 
        void Vertex4iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glVertex4iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex4iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glVertex4iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
        {
            Delegates.glVertex4s((GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex4sv(GLshort* v)
        {
            unsafe { Delegates.glVertex4sv((GLshort*)v); }
        }
        
        public static 
        void Vertex4sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertex4sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void Vertex4sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertex4sv((GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ClipPlane(GL.Enums.ClipPlaneName plane, GLdouble* equation)
        {
            unsafe { Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation); }
        }
        
        public static 
        void ClipPlane(GL.Enums.ClipPlaneName plane, GLdouble[] equation)
        {
            unsafe
            {
                fixed (GLdouble* equation_ptr = equation)
                {
                    Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation_ptr);
                }
            }
        }
        
        public static 
        void ClipPlane(GL.Enums.ClipPlaneName plane, ref GLdouble equation)
        {
            unsafe
            {
                fixed (GLdouble* equation_ptr = &equation)
                {
                    Delegates.glClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation_ptr);
                }
            }
        }
        
        public static 
        void ColorMaterial(GL.Enums.MaterialFace face, GL.Enums.ColorMaterialParameter mode)
        {
            Delegates.glColorMaterial((GL.Enums.MaterialFace)face, (GL.Enums.ColorMaterialParameter)mode);
        }
        
        public static 
        void CullFace(GL.Enums.CullFaceMode mode)
        {
            Delegates.glCullFace((GL.Enums.CullFaceMode)mode);
        }
        
        public static 
        void Fogf(GL.Enums.FogParameter pname, GLfloat param)
        {
            Delegates.glFogf((GL.Enums.FogParameter)pname, (GLfloat)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Fogfv(GL.Enums.FogParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glFogfv((GL.Enums.FogParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void Fogfv(GL.Enums.FogParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glFogfv((GL.Enums.FogParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void Fogfv(GL.Enums.FogParameter pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glFogfv((GL.Enums.FogParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void Fogi(GL.Enums.FogParameter pname, GLint param)
        {
            Delegates.glFogi((GL.Enums.FogParameter)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Fogiv(GL.Enums.FogParameter pname, GLint* @params)
        {
            unsafe { Delegates.glFogiv((GL.Enums.FogParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void Fogiv(GL.Enums.FogParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glFogiv((GL.Enums.FogParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void Fogiv(GL.Enums.FogParameter pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glFogiv((GL.Enums.FogParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void FrontFace(GL.Enums.FrontFaceDirection mode)
        {
            Delegates.glFrontFace((GL.Enums.FrontFaceDirection)mode);
        }
        
        public static 
        void Hint(GL.Enums.HintTarget target, GL.Enums.HintMode mode)
        {
            Delegates.glHint((GL.Enums.HintTarget)target, (GL.Enums.HintMode)mode);
        }
        
        public static 
        void Lightf(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat param)
        {
            Delegates.glLightf((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Lightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void Lightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void Lightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void Lighti(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint param)
        {
            Delegates.glLighti((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Lightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint* @params)
        {
            unsafe { Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void Lightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void Lightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void LightModelf(GL.Enums.LightModelParameter pname, GLfloat param)
        {
            Delegates.glLightModelf((GL.Enums.LightModelParameter)pname, (GLfloat)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void LightModelfv(GL.Enums.LightModelParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void LightModelfv(GL.Enums.LightModelParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void LightModelfv(GL.Enums.LightModelParameter pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glLightModelfv((GL.Enums.LightModelParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void LightModeli(GL.Enums.LightModelParameter pname, GLint param)
        {
            Delegates.glLightModeli((GL.Enums.LightModelParameter)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void LightModeliv(GL.Enums.LightModelParameter pname, GLint* @params)
        {
            unsafe { Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void LightModeliv(GL.Enums.LightModelParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void LightModeliv(GL.Enums.LightModelParameter pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glLightModeliv((GL.Enums.LightModelParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void LineStipple(GLint factor, Int16 pattern)
        {
            unsafe
            {
                {
                    Delegates.glLineStipple((GLint)factor, (GLushort)pattern);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void LineStipple(GLint factor, GLushort pattern)
        {
             Delegates.glLineStipple((GLint)factor, (GLushort)pattern); 
        }
        
        public static 
        void LineWidth(GLfloat width)
        {
            Delegates.glLineWidth((GLfloat)width);
        }
        
        public static 
        void Materialf(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat param)
        {
            Delegates.glMaterialf((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Materialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void Materialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void Materialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void Materiali(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint param)
        {
            Delegates.glMateriali((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Materialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint* @params)
        {
            unsafe { Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void Materialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void Materialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void PointSize(GLfloat size)
        {
            Delegates.glPointSize((GLfloat)size);
        }
        
        public static 
        void PolygonMode(GL.Enums.MaterialFace face, GL.Enums.PolygonMode mode)
        {
            Delegates.glPolygonMode((GL.Enums.MaterialFace)face, (GL.Enums.PolygonMode)mode);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PolygonStipple(GLubyte* mask)
        {
            unsafe { Delegates.glPolygonStipple((GLubyte*)mask); }
        }
        
        public static 
        void PolygonStipple(GLubyte[] mask)
        {
            unsafe
            {
                fixed (GLubyte* mask_ptr = mask)
                {
                    Delegates.glPolygonStipple((GLubyte*)mask_ptr);
                }
            }
        }
        
        public static 
        void PolygonStipple(ref GLubyte mask)
        {
            unsafe
            {
                fixed (GLubyte* mask_ptr = &mask)
                {
                    Delegates.glPolygonStipple((GLubyte*)mask_ptr);
                }
            }
        }
        
        public static 
        void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
        {
            Delegates.glScissor((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
        }
        
        public static 
        void ShadeModel(GL.Enums.ShadingModel mode)
        {
            Delegates.glShadeModel((GL.Enums.ShadingModel)mode);
        }
        
        public static 
        void TexParameterf(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLfloat param)
        {
            Delegates.glTexParameterf((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLfloat)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexParameterfv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLfloat* @params)
        {
            unsafe { Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLfloat*)@params); }
        }
        
        public static 
        void TexParameterfv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexParameterfv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexParameteri(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint param)
        {
            Delegates.glTexParameteri((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexParameteriv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint* @params)
        {
            unsafe { Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params); }
        }
        
        public static 
        void TexParameteriv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexParameteriv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexImage1D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void TexImage1D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexImage2D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void TexImage2D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        public static 
        void TexEnvf(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat param)
        {
            Delegates.glTexEnvf((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void TexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexEnvi(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint param)
        {
            Delegates.glTexEnvi((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint* @params)
        {
            unsafe { Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void TexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexGend(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble param)
        {
            Delegates.glTexGend((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble* @params)
        {
            unsafe { Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params); }
        }
        
        public static 
        void TexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble[] @params)
        {
            unsafe
            {
                fixed (GLdouble* @params_ptr = @params)
                {
                    Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref GLdouble @params)
        {
            unsafe
            {
                fixed (GLdouble* @params_ptr = &@params)
                {
                    Delegates.glTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexGenf(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat param)
        {
            Delegates.glTexGenf((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void TexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexGeni(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint param)
        {
            Delegates.glTexGeni((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint* @params)
        {
            unsafe { Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void TexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void TexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void FeedbackBuffer(GLsizei size, GL.Enums.FeedbackType type, GLfloat* buffer)
        {
            unsafe { Delegates.glFeedbackBuffer((GLsizei)size, (GL.Enums.FeedbackType)type, (GLfloat*)buffer); }
        }
        
        public static 
        void FeedbackBuffer(GLsizei size, GL.Enums.FeedbackType type, GLfloat[] buffer)
        {
            unsafe
            {
                fixed (GLfloat* buffer_ptr = buffer)
                {
                    Delegates.glFeedbackBuffer((GLsizei)size, (GL.Enums.FeedbackType)type, (GLfloat*)buffer_ptr);
                }
            }
        }
        
        public static 
        void FeedbackBuffer(GLsizei size, GL.Enums.FeedbackType type, out GLfloat buffer)
        {
            buffer = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* buffer_ptr = &buffer)
                {
                    Delegates.glFeedbackBuffer((GLsizei)size, (GL.Enums.FeedbackType)type, (GLfloat*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SelectBuffer(GLsizei size, Int32* buffer)
        {
            buffer = default(Int32*);
                {
                    Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SelectBuffer(GLsizei size, GLuint* buffer)
        {
            unsafe { Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer); }
        }
        
        public static 
        void SelectBuffer(GLsizei size, Int32[] buffer)
        {
            unsafe
            {
                fixed (Int32* buffer_ptr = buffer)
                {
                    Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SelectBuffer(GLsizei size, GLuint[] buffer)
        {
            unsafe
            {
                fixed (GLuint* buffer_ptr = buffer)
                {
                    Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer_ptr);
                }
            }
        }
        
        public static 
        void SelectBuffer(GLsizei size, out Int32 buffer)
        {
            buffer = default(Int32);
            unsafe
            {
                fixed (Int32* buffer_ptr = &buffer)
                {
                    Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SelectBuffer(GLsizei size, out GLuint buffer)
        {
            buffer = default(GLuint);
            unsafe
            {
                fixed (GLuint* buffer_ptr = &buffer)
                {
                    Delegates.glSelectBuffer((GLsizei)size, (GLuint*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }
        
        public static 
        GLint RenderMode(GL.Enums.RenderingMode mode)
        {
            return Delegates.glRenderMode((GL.Enums.RenderingMode)mode);
        }
        
        public static 
        void InitNames()
        {
            Delegates.glInitNames();
        }
        
        public static 
        void LoadName(Int32 name)
        {
            Delegates.glLoadName((GLuint)name);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void LoadName(GLuint name)
        {
            Delegates.glLoadName((GLuint)name);
        }
        
        public static 
        void PassThrough(GLfloat token)
        {
            Delegates.glPassThrough((GLfloat)token);
        }
        
        public static 
        void PopName()
        {
            Delegates.glPopName();
        }
        
        public static 
        void PushName(Int32 name)
        {
            Delegates.glPushName((GLuint)name);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PushName(GLuint name)
        {
            Delegates.glPushName((GLuint)name);
        }
        
        public static 
        void DrawBuffer(GL.Enums.DrawBufferMode mode)
        {
            Delegates.glDrawBuffer((GL.Enums.DrawBufferMode)mode);
        }
        
        public static 
        void Clear(GL.Enums.ClearBufferMask mask)
        {
            Delegates.glClear((GL.Enums.ClearBufferMask)mask);
        }
        
        public static 
        void ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
        {
            Delegates.glClearAccum((GLfloat)red, (GLfloat)green, (GLfloat)blue, (GLfloat)alpha);
        }
        
        public static 
        void ClearIndex(GLfloat c)
        {
            Delegates.glClearIndex((GLfloat)c);
        }
        
        public static 
        void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
        {
            Delegates.glClearColor((GLclampf)red, (GLclampf)green, (GLclampf)blue, (GLclampf)alpha);
        }
        
        public static 
        void ClearStencil(GLint s)
        {
            Delegates.glClearStencil((GLint)s);
        }
        
        public static 
        void ClearDepth(GLclampd depth)
        {
            Delegates.glClearDepth((GLclampd)depth);
        }
        
        public static 
        void StencilMask(Int32 mask)
        {
            Delegates.glStencilMask((GLuint)mask);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void StencilMask(GLuint mask)
        {
            Delegates.glStencilMask((GLuint)mask);
        }
        
        public static 
        void ColorMask(GL.Enums.Boolean red, GL.Enums.Boolean green, GL.Enums.Boolean blue, GL.Enums.Boolean alpha)
        {
             Delegates.glColorMask((GL.Enums.Boolean)red, (GL.Enums.Boolean)green, (GL.Enums.Boolean)blue, (GL.Enums.Boolean)alpha); 
        }
        
        public static 
        void DepthMask(GL.Enums.Boolean flag)
        {
             Delegates.glDepthMask((GL.Enums.Boolean)flag); 
        }
        
        public static 
        void IndexMask(Int32 mask)
        {
            Delegates.glIndexMask((GLuint)mask);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void IndexMask(GLuint mask)
        {
            Delegates.glIndexMask((GLuint)mask);
        }
        
        public static 
        void Accum(GL.Enums.AccumOp op, GLfloat value)
        {
            Delegates.glAccum((GL.Enums.AccumOp)op, (GLfloat)value);
        }
        
        public static 
        void Disable(GL.Enums.EnableCap cap)
        {
            Delegates.glDisable((GL.Enums.EnableCap)cap);
        }
        
        public static 
        void Enable(GL.Enums.EnableCap cap)
        {
            Delegates.glEnable((GL.Enums.EnableCap)cap);
        }
        
        public static 
        void Finish()
        {
            Delegates.glFinish();
        }
        
        public static 
        void Flush()
        {
            Delegates.glFlush();
        }
        
        public static 
        void PopAttrib()
        {
            Delegates.glPopAttrib();
        }
        
        public static 
        void PushAttrib(GL.Enums.AttribMask mask)
        {
            Delegates.glPushAttrib((GL.Enums.AttribMask)mask);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Map1d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble* points)
        {
            unsafe { Delegates.glMap1d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)stride, (GLint)order, (GLdouble*)points); }
        }
        
        public static 
        void Map1d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble[] points)
        {
            unsafe
            {
                fixed (GLdouble* points_ptr = points)
                {
                    Delegates.glMap1d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)stride, (GLint)order, (GLdouble*)points_ptr);
                }
            }
        }
        
        public static 
        void Map1d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, ref GLdouble points)
        {
            unsafe
            {
                fixed (GLdouble* points_ptr = &points)
                {
                    Delegates.glMap1d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)stride, (GLint)order, (GLdouble*)points_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Map1f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat* points)
        {
            unsafe { Delegates.glMap1f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)stride, (GLint)order, (GLfloat*)points); }
        }
        
        public static 
        void Map1f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat[] points)
        {
            unsafe
            {
                fixed (GLfloat* points_ptr = points)
                {
                    Delegates.glMap1f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)stride, (GLint)order, (GLfloat*)points_ptr);
                }
            }
        }
        
        public static 
        void Map1f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, ref GLfloat points)
        {
            unsafe
            {
                fixed (GLfloat* points_ptr = &points)
                {
                    Delegates.glMap1f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)stride, (GLint)order, (GLfloat*)points_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Map2d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble* points)
        {
            unsafe { Delegates.glMap2d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble*)points); }
        }
        
        public static 
        void Map2d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble[] points)
        {
            unsafe
            {
                fixed (GLdouble* points_ptr = points)
                {
                    Delegates.glMap2d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble*)points_ptr);
                }
            }
        }
        
        public static 
        void Map2d(GL.Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, ref GLdouble points)
        {
            unsafe
            {
                fixed (GLdouble* points_ptr = &points)
                {
                    Delegates.glMap2d((GL.Enums.MapTarget)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble*)points_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Map2f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat* points)
        {
            unsafe { Delegates.glMap2f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat*)points); }
        }
        
        public static 
        void Map2f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat[] points)
        {
            unsafe
            {
                fixed (GLfloat* points_ptr = points)
                {
                    Delegates.glMap2f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat*)points_ptr);
                }
            }
        }
        
        public static 
        void Map2f(GL.Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, ref GLfloat points)
        {
            unsafe
            {
                fixed (GLfloat* points_ptr = &points)
                {
                    Delegates.glMap2f((GL.Enums.MapTarget)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat*)points_ptr);
                }
            }
        }
        
        public static 
        void MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
        {
            Delegates.glMapGrid1d((GLint)un, (GLdouble)u1, (GLdouble)u2);
        }
        
        public static 
        void MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
        {
            Delegates.glMapGrid1f((GLint)un, (GLfloat)u1, (GLfloat)u2);
        }
        
        public static 
        void MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
        {
            Delegates.glMapGrid2d((GLint)un, (GLdouble)u1, (GLdouble)u2, (GLint)vn, (GLdouble)v1, (GLdouble)v2);
        }
        
        public static 
        void MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
        {
            Delegates.glMapGrid2f((GLint)un, (GLfloat)u1, (GLfloat)u2, (GLint)vn, (GLfloat)v1, (GLfloat)v2);
        }
        
        public static 
        void EvalCoord1d(GLdouble u)
        {
            Delegates.glEvalCoord1d((GLdouble)u);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void EvalCoord1dv(GLdouble* u)
        {
            unsafe { Delegates.glEvalCoord1dv((GLdouble*)u); }
        }
        
        public static 
        void EvalCoord1dv(GLdouble[] u)
        {
            unsafe
            {
                fixed (GLdouble* u_ptr = u)
                {
                    Delegates.glEvalCoord1dv((GLdouble*)u_ptr);
                }
            }
        }
        
        public static 
        void EvalCoord1dv(ref GLdouble u)
        {
            unsafe
            {
                fixed (GLdouble* u_ptr = &u)
                {
                    Delegates.glEvalCoord1dv((GLdouble*)u_ptr);
                }
            }
        }
        
        public static 
        void EvalCoord1f(GLfloat u)
        {
            Delegates.glEvalCoord1f((GLfloat)u);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void EvalCoord1fv(GLfloat* u)
        {
            unsafe { Delegates.glEvalCoord1fv((GLfloat*)u); }
        }
        
        public static 
        void EvalCoord1fv(GLfloat[] u)
        {
            unsafe
            {
                fixed (GLfloat* u_ptr = u)
                {
                    Delegates.glEvalCoord1fv((GLfloat*)u_ptr);
                }
            }
        }
        
        public static 
        void EvalCoord1fv(ref GLfloat u)
        {
            unsafe
            {
                fixed (GLfloat* u_ptr = &u)
                {
                    Delegates.glEvalCoord1fv((GLfloat*)u_ptr);
                }
            }
        }
        
        public static 
        void EvalCoord2d(GLdouble u, GLdouble v)
        {
            Delegates.glEvalCoord2d((GLdouble)u, (GLdouble)v);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void EvalCoord2dv(GLdouble* u)
        {
            unsafe { Delegates.glEvalCoord2dv((GLdouble*)u); }
        }
        
        public static 
        void EvalCoord2dv(GLdouble[] u)
        {
            unsafe
            {
                fixed (GLdouble* u_ptr = u)
                {
                    Delegates.glEvalCoord2dv((GLdouble*)u_ptr);
                }
            }
        }
        
        public static 
        void EvalCoord2dv(ref GLdouble u)
        {
            unsafe
            {
                fixed (GLdouble* u_ptr = &u)
                {
                    Delegates.glEvalCoord2dv((GLdouble*)u_ptr);
                }
            }
        }
        
        public static 
        void EvalCoord2f(GLfloat u, GLfloat v)
        {
            Delegates.glEvalCoord2f((GLfloat)u, (GLfloat)v);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void EvalCoord2fv(GLfloat* u)
        {
            unsafe { Delegates.glEvalCoord2fv((GLfloat*)u); }
        }
        
        public static 
        void EvalCoord2fv(GLfloat[] u)
        {
            unsafe
            {
                fixed (GLfloat* u_ptr = u)
                {
                    Delegates.glEvalCoord2fv((GLfloat*)u_ptr);
                }
            }
        }
        
        public static 
        void EvalCoord2fv(ref GLfloat u)
        {
            unsafe
            {
                fixed (GLfloat* u_ptr = &u)
                {
                    Delegates.glEvalCoord2fv((GLfloat*)u_ptr);
                }
            }
        }
        
        public static 
        void EvalMesh1(GL.Enums.MeshMode1 mode, GLint i1, GLint i2)
        {
            Delegates.glEvalMesh1((GL.Enums.MeshMode1)mode, (GLint)i1, (GLint)i2);
        }
        
        public static 
        void EvalPoint1(GLint i)
        {
            Delegates.glEvalPoint1((GLint)i);
        }
        
        public static 
        void EvalMesh2(GL.Enums.MeshMode2 mode, GLint i1, GLint i2, GLint j1, GLint j2)
        {
            Delegates.glEvalMesh2((GL.Enums.MeshMode2)mode, (GLint)i1, (GLint)i2, (GLint)j1, (GLint)j2);
        }
        
        public static 
        void EvalPoint2(GLint i, GLint j)
        {
            Delegates.glEvalPoint2((GLint)i, (GLint)j);
        }
        
        public static 
        void AlphaFunc(GL.Enums.AlphaFunction func, GLclampf @ref)
        {
            Delegates.glAlphaFunc((GL.Enums.AlphaFunction)func, (GLclampf)@ref);
        }
        
        public static 
        void BlendFunc(GL.Enums.BlendingFactorSrc sfactor, GL.Enums.BlendingFactorDest dfactor)
        {
            Delegates.glBlendFunc((GL.Enums.BlendingFactorSrc)sfactor, (GL.Enums.BlendingFactorDest)dfactor);
        }
        
        public static 
        void LogicOp(GL.Enums.LogicOp opcode)
        {
            Delegates.glLogicOp((GL.Enums.LogicOp)opcode);
        }
        
        public static 
        void StencilFunc(GL.Enums.StencilFunction func, GLint @ref, Int32 mask)
        {
            Delegates.glStencilFunc((GL.Enums.StencilFunction)func, (GLint)@ref, (GLuint)mask);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void StencilFunc(GL.Enums.StencilFunction func, GLint @ref, GLuint mask)
        {
            Delegates.glStencilFunc((GL.Enums.StencilFunction)func, (GLint)@ref, (GLuint)mask);
        }
        
        public static 
        void StencilOp(GL.Enums.StencilOp fail, GL.Enums.StencilOp zfail, GL.Enums.StencilOp zpass)
        {
            Delegates.glStencilOp((GL.Enums.StencilOp)fail, (GL.Enums.StencilOp)zfail, (GL.Enums.StencilOp)zpass);
        }
        
        public static 
        void DepthFunc(GL.Enums.DepthFunction func)
        {
            Delegates.glDepthFunc((GL.Enums.DepthFunction)func);
        }
        
        public static 
        void PixelZoom(GLfloat xfactor, GLfloat yfactor)
        {
            Delegates.glPixelZoom((GLfloat)xfactor, (GLfloat)yfactor);
        }
        
        public static 
        void PixelTransferf(GL.Enums.PixelTransferParameter pname, GLfloat param)
        {
            Delegates.glPixelTransferf((GL.Enums.PixelTransferParameter)pname, (GLfloat)param);
        }
        
        public static 
        void PixelTransferi(GL.Enums.PixelTransferParameter pname, GLint param)
        {
            Delegates.glPixelTransferi((GL.Enums.PixelTransferParameter)pname, (GLint)param);
        }
        
        public static 
        void PixelStoref(GL.Enums.PixelStoreParameter pname, GLfloat param)
        {
            Delegates.glPixelStoref((GL.Enums.PixelStoreParameter)pname, (GLfloat)param);
        }
        
        public static 
        void PixelStorei(GL.Enums.PixelStoreParameter pname, GLint param)
        {
            Delegates.glPixelStorei((GL.Enums.PixelStoreParameter)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMapfv(GL.Enums.PixelMap map, GLint mapsize, GLfloat* values)
        {
            unsafe { Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLfloat*)values); }
        }
        
        public static 
        void PixelMapfv(GL.Enums.PixelMap map, GLint mapsize, GLfloat[] values)
        {
            unsafe
            {
                fixed (GLfloat* values_ptr = values)
                {
                    Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLfloat*)values_ptr);
                }
            }
        }
        
        public static 
        void PixelMapfv(GL.Enums.PixelMap map, GLint mapsize, ref GLfloat values)
        {
            unsafe
            {
                fixed (GLfloat* values_ptr = &values)
                {
                    Delegates.glPixelMapfv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLfloat*)values_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, Int32* values)
        {
                {
                    Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, GLuint* values)
        {
            unsafe { Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values); }
        }
        
        public static 
        void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, Int32[] values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = values)
                {
                    Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, GLuint[] values)
        {
            unsafe
            {
                fixed (GLuint* values_ptr = values)
                {
                    Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values_ptr);
                }
            }
        }
        
        public static 
        void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, ref Int32 values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = &values)
                {
                    Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PixelMapuiv(GL.Enums.PixelMap map, GLint mapsize, ref GLuint values)
        {
            unsafe
            {
                fixed (GLuint* values_ptr = &values)
                {
                    Delegates.glPixelMapuiv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLuint*)values_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, Int16* values)
        {
                {
                    Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, GLushort* values)
        {
            unsafe { Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values); }
        }
        
        public static 
        void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, Int16[] values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = values)
                {
                    Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, GLushort[] values)
        {
            unsafe
            {
                fixed (GLushort* values_ptr = values)
                {
                    Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values_ptr);
                }
            }
        }
        
        public static 
        void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, ref Int16 values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = &values)
                {
                    Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PixelMapusv(GL.Enums.PixelMap map, GLint mapsize, ref GLushort values)
        {
            unsafe
            {
                fixed (GLushort* values_ptr = &values)
                {
                    Delegates.glPixelMapusv((GL.Enums.PixelMap)map, (GLint)mapsize, (GLushort*)values_ptr);
                }
            }
        }
        
        public static 
        void ReadBuffer(GL.Enums.ReadBufferMode mode)
        {
            Delegates.glReadBuffer((GL.Enums.ReadBufferMode)mode);
        }
        
        public static 
        void CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL.Enums.PixelCopyType type)
        {
            Delegates.glCopyPixels((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelCopyType)type);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glReadPixels((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glReadPixels((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DrawPixels(GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glDrawPixels((GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void DrawPixels(GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glDrawPixels((GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetBooleanv(GL.Enums.GetPName pname, GL.Enums.Boolean* @params)
        {
            unsafe { Delegates.glGetBooleanv((GL.Enums.GetPName)pname, (GL.Enums.Boolean*)@params); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetClipPlane(GL.Enums.ClipPlaneName plane, GLdouble* equation)
        {
            unsafe { Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation); }
        }
        
        public static 
        void GetClipPlane(GL.Enums.ClipPlaneName plane, GLdouble[] equation)
        {
            unsafe
            {
                fixed (GLdouble* equation_ptr = equation)
                {
                    Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation_ptr);
                }
            }
        }
        
        public static 
        void GetClipPlane(GL.Enums.ClipPlaneName plane, out GLdouble equation)
        {
            equation = default(GLdouble);
            unsafe
            {
                fixed (GLdouble* equation_ptr = &equation)
                {
                    Delegates.glGetClipPlane((GL.Enums.ClipPlaneName)plane, (GLdouble*)equation_ptr);
                    equation = *equation_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetDoublev(GL.Enums.GetPName pname, GLdouble* @params)
        {
            unsafe { Delegates.glGetDoublev((GL.Enums.GetPName)pname, (GLdouble*)@params); }
        }
        
        public static 
        void GetDoublev(GL.Enums.GetPName pname, GLdouble[] @params)
        {
            unsafe
            {
                fixed (GLdouble* @params_ptr = @params)
                {
                    Delegates.glGetDoublev((GL.Enums.GetPName)pname, (GLdouble*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetDoublev(GL.Enums.GetPName pname, out GLdouble @params)
        {
            @params = default(GLdouble);
            unsafe
            {
                fixed (GLdouble* @params_ptr = &@params)
                {
                    Delegates.glGetDoublev((GL.Enums.GetPName)pname, (GLdouble*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        public static 
        GL.Enums.GLenum GetError()
        {
            return Delegates.glGetError();
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetFloatv(GL.Enums.GetPName pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetFloatv((GL.Enums.GetPName)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetFloatv(GL.Enums.GetPName pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetFloatv((GL.Enums.GetPName)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetFloatv(GL.Enums.GetPName pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetFloatv((GL.Enums.GetPName)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetIntegerv(GL.Enums.GetPName pname, GLint* @params)
        {
            unsafe { Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (GLint*)@params); }
        }
        
        public static 
        void GetIntegerv(GL.Enums.GetPName pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetIntegerv(GL.Enums.GetPName pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetIntegerv((GL.Enums.GetPName)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetLightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetLightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetLightfv(GL.Enums.LightName light, GL.Enums.LightParameter pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetLightfv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetLightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint* @params)
        {
            unsafe { Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void GetLightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetLightiv(GL.Enums.LightName light, GL.Enums.LightParameter pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetLightiv((GL.Enums.LightName)light, (GL.Enums.LightParameter)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMapdv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLdouble* v)
        {
            unsafe { Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLdouble*)v); }
        }
        
        public static 
        void GetMapdv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void GetMapdv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, out GLdouble v)
        {
            v = default(GLdouble);
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glGetMapdv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLdouble*)v_ptr);
                    v = *v_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMapfv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLfloat* v)
        {
            unsafe { Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLfloat*)v); }
        }
        
        public static 
        void GetMapfv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void GetMapfv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, out GLfloat v)
        {
            v = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glGetMapfv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLfloat*)v_ptr);
                    v = *v_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMapiv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLint* v)
        {
            unsafe { Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLint*)v); }
        }
        
        public static 
        void GetMapiv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void GetMapiv(GL.Enums.MapTarget target, GL.Enums.GetMapQuery query, out GLint v)
        {
            v = default(GLint);
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glGetMapiv((GL.Enums.MapTarget)target, (GL.Enums.GetMapQuery)query, (GLint*)v_ptr);
                    v = *v_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetMaterialfv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint* @params)
        {
            unsafe { Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void GetMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetMaterialiv((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMapfv(GL.Enums.PixelMap map, GLfloat* values)
        {
            unsafe { Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (GLfloat*)values); }
        }
        
        public static 
        void GetPixelMapfv(GL.Enums.PixelMap map, GLfloat[] values)
        {
            unsafe
            {
                fixed (GLfloat* values_ptr = values)
                {
                    Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (GLfloat*)values_ptr);
                }
            }
        }
        
        public static 
        void GetPixelMapfv(GL.Enums.PixelMap map, out GLfloat values)
        {
            values = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* values_ptr = &values)
                {
                    Delegates.glGetPixelMapfv((GL.Enums.PixelMap)map, (GLfloat*)values_ptr);
                    values = *values_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMapuiv(GL.Enums.PixelMap map, Int32* values)
        {
            values = default(Int32*);
                {
                    Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMapuiv(GL.Enums.PixelMap map, GLuint* values)
        {
            unsafe { Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values); }
        }
        
        public static 
        void GetPixelMapuiv(GL.Enums.PixelMap map, Int32[] values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = values)
                {
                    Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetPixelMapuiv(GL.Enums.PixelMap map, GLuint[] values)
        {
            unsafe
            {
                fixed (GLuint* values_ptr = values)
                {
                    Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values_ptr);
                }
            }
        }
        
        public static 
        void GetPixelMapuiv(GL.Enums.PixelMap map, out Int32 values)
        {
            values = default(Int32);
            unsafe
            {
                fixed (Int32* values_ptr = &values)
                {
                    Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values_ptr);
                    values = *values_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetPixelMapuiv(GL.Enums.PixelMap map, out GLuint values)
        {
            values = default(GLuint);
            unsafe
            {
                fixed (GLuint* values_ptr = &values)
                {
                    Delegates.glGetPixelMapuiv((GL.Enums.PixelMap)map, (GLuint*)values_ptr);
                    values = *values_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMapusv(GL.Enums.PixelMap map, Int16* values)
        {
            values = default(Int16*);
                {
                    Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMapusv(GL.Enums.PixelMap map, GLushort* values)
        {
            unsafe { Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values); }
        }
        
        public static 
        void GetPixelMapusv(GL.Enums.PixelMap map, Int16[] values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = values)
                {
                    Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetPixelMapusv(GL.Enums.PixelMap map, GLushort[] values)
        {
            unsafe
            {
                fixed (GLushort* values_ptr = values)
                {
                    Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values_ptr);
                }
            }
        }
        
        public static 
        void GetPixelMapusv(GL.Enums.PixelMap map, out Int16 values)
        {
            values = default(Int16);
            unsafe
            {
                fixed (Int16* values_ptr = &values)
                {
                    Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values_ptr);
                    values = *values_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetPixelMapusv(GL.Enums.PixelMap map, out GLushort values)
        {
            values = default(GLushort);
            unsafe
            {
                fixed (GLushort* values_ptr = &values)
                {
                    Delegates.glGetPixelMapusv((GL.Enums.PixelMap)map, (GLushort*)values_ptr);
                    values = *values_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPolygonStipple(GLubyte* mask)
        {
            unsafe { Delegates.glGetPolygonStipple((GLubyte*)mask); }
        }
        
        public static 
        void GetPolygonStipple(GLubyte[] mask)
        {
            unsafe
            {
                fixed (GLubyte* mask_ptr = mask)
                {
                    Delegates.glGetPolygonStipple((GLubyte*)mask_ptr);
                }
            }
        }
        
        public static 
        void GetPolygonStipple(out GLubyte mask)
        {
            mask = default(GLubyte);
            unsafe
            {
                fixed (GLubyte* mask_ptr = &mask)
                {
                    Delegates.glGetPolygonStipple((GLubyte*)mask_ptr);
                    mask = *mask_ptr;
                }
            }
        }
        
        public static 
        System.String GetString(GL.Enums.StringName name)
        {
            return System.Runtime.InteropServices.Marshal.PtrToStringAnsi(Delegates.glGetString((GL.Enums.StringName)name));
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetTexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexEnvfv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetTexEnvfv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint* @params)
        {
            unsafe { Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void GetTexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexEnviv(GL.Enums.TextureEnvTarget target, GL.Enums.TextureEnvParameter pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetTexEnviv((GL.Enums.TextureEnvTarget)target, (GL.Enums.TextureEnvParameter)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble* @params)
        {
            unsafe { Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params); }
        }
        
        public static 
        void GetTexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLdouble[] @params)
        {
            unsafe
            {
                fixed (GLdouble* @params_ptr = @params)
                {
                    Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexGendv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, out GLdouble @params)
        {
            @params = default(GLdouble);
            unsafe
            {
                fixed (GLdouble* @params_ptr = &@params)
                {
                    Delegates.glGetTexGendv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLdouble*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetTexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexGenfv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetTexGenfv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint* @params)
        {
            unsafe { Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void GetTexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexGeniv(GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetTexGeniv((GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexImage(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glGetTexImage((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void GetTexImage(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetTexImage((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexParameterfv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetTexParameterfv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexParameterfv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameterfv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexParameteriv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLint* @params)
        {
            unsafe { Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void GetTexParameteriv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexParameteriv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameteriv((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexLevelParameterfv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetTexLevelParameterfv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexLevelParameterfv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetTexLevelParameterfv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexLevelParameteriv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, GLint* @params)
        {
            unsafe { Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLint*)@params); }
        }
        
        public static 
        void GetTexLevelParameteriv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetTexLevelParameteriv(GL.Enums.TextureTarget target, GLint level, GL.Enums.GetTextureParameter pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetTexLevelParameteriv((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        public static 
        GLboolean IsEnabled(GL.Enums.EnableCap cap)
        {
            return Delegates.glIsEnabled((GL.Enums.EnableCap)cap);
        }
        
        public static 
        GLboolean IsList(Int32 list)
        {
            return Delegates.glIsList((GLuint)list);
        }
        
        [System.CLSCompliant(false)]
        public static 
        GLboolean IsList(GLuint list)
        {
            return Delegates.glIsList((GLuint)list);
        }
        
        public static 
        void DepthRange(GLclampd near, GLclampd far)
        {
            Delegates.glDepthRange((GLclampd)near, (GLclampd)far);
        }
        
        public static 
        void Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
        {
            Delegates.glFrustum((GLdouble)left, (GLdouble)right, (GLdouble)bottom, (GLdouble)top, (GLdouble)zNear, (GLdouble)zFar);
        }
        
        public static 
        void LoadIdentity()
        {
            Delegates.glLoadIdentity();
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void LoadMatrixf(GLfloat* m)
        {
            unsafe { Delegates.glLoadMatrixf((GLfloat*)m); }
        }
        
        public static 
        void LoadMatrixf(GLfloat[] m)
        {
            unsafe
            {
                fixed (GLfloat* m_ptr = m)
                {
                    Delegates.glLoadMatrixf((GLfloat*)m_ptr);
                }
            }
        }
        
        public static 
        void LoadMatrixf(ref GLfloat m)
        {
            unsafe
            {
                fixed (GLfloat* m_ptr = &m)
                {
                    Delegates.glLoadMatrixf((GLfloat*)m_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void LoadMatrixd(GLdouble* m)
        {
            unsafe { Delegates.glLoadMatrixd((GLdouble*)m); }
        }
        
        public static 
        void LoadMatrixd(GLdouble[] m)
        {
            unsafe
            {
                fixed (GLdouble* m_ptr = m)
                {
                    Delegates.glLoadMatrixd((GLdouble*)m_ptr);
                }
            }
        }
        
        public static 
        void LoadMatrixd(ref GLdouble m)
        {
            unsafe
            {
                fixed (GLdouble* m_ptr = &m)
                {
                    Delegates.glLoadMatrixd((GLdouble*)m_ptr);
                }
            }
        }
        
        public static 
        void MatrixMode(GL.Enums.MatrixMode mode)
        {
            Delegates.glMatrixMode((GL.Enums.MatrixMode)mode);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultMatrixf(GLfloat* m)
        {
            unsafe { Delegates.glMultMatrixf((GLfloat*)m); }
        }
        
        public static 
        void MultMatrixf(GLfloat[] m)
        {
            unsafe
            {
                fixed (GLfloat* m_ptr = m)
                {
                    Delegates.glMultMatrixf((GLfloat*)m_ptr);
                }
            }
        }
        
        public static 
        void MultMatrixf(ref GLfloat m)
        {
            unsafe
            {
                fixed (GLfloat* m_ptr = &m)
                {
                    Delegates.glMultMatrixf((GLfloat*)m_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultMatrixd(GLdouble* m)
        {
            unsafe { Delegates.glMultMatrixd((GLdouble*)m); }
        }
        
        public static 
        void MultMatrixd(GLdouble[] m)
        {
            unsafe
            {
                fixed (GLdouble* m_ptr = m)
                {
                    Delegates.glMultMatrixd((GLdouble*)m_ptr);
                }
            }
        }
        
        public static 
        void MultMatrixd(ref GLdouble m)
        {
            unsafe
            {
                fixed (GLdouble* m_ptr = &m)
                {
                    Delegates.glMultMatrixd((GLdouble*)m_ptr);
                }
            }
        }
        
        public static 
        void Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
        {
            Delegates.glOrtho((GLdouble)left, (GLdouble)right, (GLdouble)bottom, (GLdouble)top, (GLdouble)zNear, (GLdouble)zFar);
        }
        
        public static 
        void PopMatrix()
        {
            Delegates.glPopMatrix();
        }
        
        public static 
        void PushMatrix()
        {
            Delegates.glPushMatrix();
        }
        
        public static 
        void Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
        {
            Delegates.glRotated((GLdouble)angle, (GLdouble)x, (GLdouble)y, (GLdouble)z);
        }
        
        public static 
        void Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
        {
            Delegates.glRotatef((GLfloat)angle, (GLfloat)x, (GLfloat)y, (GLfloat)z);
        }
        
        public static 
        void Scaled(GLdouble x, GLdouble y, GLdouble z)
        {
            Delegates.glScaled((GLdouble)x, (GLdouble)y, (GLdouble)z);
        }
        
        public static 
        void Scalef(GLfloat x, GLfloat y, GLfloat z)
        {
            Delegates.glScalef((GLfloat)x, (GLfloat)y, (GLfloat)z);
        }
        
        public static 
        void Translated(GLdouble x, GLdouble y, GLdouble z)
        {
            Delegates.glTranslated((GLdouble)x, (GLdouble)y, (GLdouble)z);
        }
        
        public static 
        void Translatef(GLfloat x, GLfloat y, GLfloat z)
        {
            Delegates.glTranslatef((GLfloat)x, (GLfloat)y, (GLfloat)z);
        }
        
        public static 
        void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
        {
            Delegates.glViewport((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
        }
        
        public static 
        void ArrayElement(GLint i)
        {
            Delegates.glArrayElement((GLint)i);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glColorPointer((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void ColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glColorPointer((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        public static 
        void DisableClientState(GL.Enums.EnableCap array)
        {
            Delegates.glDisableClientState((GL.Enums.EnableCap)array);
        }
        
        public static 
        void DrawArrays(GL.Enums.BeginMode mode, GLint first, GLsizei count)
        {
            Delegates.glDrawArrays((GL.Enums.BeginMode)mode, (GLint)first, (GLsizei)count);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DrawElements(GL.Enums.BeginMode mode, GLsizei count, GL.Enums.GLenum type, void* indices)
        {
            unsafe { Delegates.glDrawElements((GL.Enums.BeginMode)mode, (GLsizei)count, (GL.Enums.GLenum)type, (void*)indices); }
        }
        
        public static 
        void DrawElements(GL.Enums.BeginMode mode, GLsizei count, GL.Enums.GLenum type, object indices)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glDrawElements((GL.Enums.BeginMode)mode, (GLsizei)count, (GL.Enums.GLenum)type, (void*)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void EdgeFlagPointer(GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glEdgeFlagPointer((GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void EdgeFlagPointer(GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glEdgeFlagPointer((GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        public static 
        void EnableClientState(GL.Enums.EnableCap array)
        {
            Delegates.glEnableClientState((GL.Enums.EnableCap)array);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPointerv(GL.Enums.GetPointervPName pname, void* @params)
        {
            unsafe { Delegates.glGetPointerv((GL.Enums.GetPointervPName)pname, (void*)@params); }
        }
        
        public static 
        void GetPointerv(GL.Enums.GetPointervPName pname, object @params)
        {
            System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetPointerv((GL.Enums.GetPointervPName)pname, (void*)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void IndexPointer(GL.Enums.IndexPointerType type, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glIndexPointer((GL.Enums.IndexPointerType)type, (GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void IndexPointer(GL.Enums.IndexPointerType type, GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glIndexPointer((GL.Enums.IndexPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void InterleavedArrays(GL.Enums.InterleavedArrayFormat format, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glInterleavedArrays((GL.Enums.InterleavedArrayFormat)format, (GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void InterleavedArrays(GL.Enums.InterleavedArrayFormat format, GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glInterleavedArrays((GL.Enums.InterleavedArrayFormat)format, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void NormalPointer(GL.Enums.NormalPointerType type, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glNormalPointer((GL.Enums.NormalPointerType)type, (GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void NormalPointer(GL.Enums.NormalPointerType type, GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glNormalPointer((GL.Enums.NormalPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoordPointer(GLint size, GL.Enums.TexCoordPointerType type, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glTexCoordPointer((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void TexCoordPointer(GLint size, GL.Enums.TexCoordPointerType type, GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glTexCoordPointer((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexPointer(GLint size, GL.Enums.VertexPointerType type, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glVertexPointer((GLint)size, (GL.Enums.VertexPointerType)type, (GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void VertexPointer(GLint size, GL.Enums.VertexPointerType type, GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glVertexPointer((GLint)size, (GL.Enums.VertexPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        public static 
        void PolygonOffset(GLfloat factor, GLfloat units)
        {
            Delegates.glPolygonOffset((GLfloat)factor, (GLfloat)units);
        }
        
        public static 
        void CopyTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border)
        {
            Delegates.glCopyTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLint)border);
        }
        
        public static 
        void CopyTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
        {
            Delegates.glCopyTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GLint)border);
        }
        
        public static 
        void CopyTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
        {
            Delegates.glCopyTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)x, (GLint)y, (GLsizei)width);
        }
        
        public static 
        void CopyTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
        {
            Delegates.glCopyTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void TexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void TexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe GLboolean AreTexturesResident(GLsizei n, Int32* textures, GL.Enums.Boolean* residences)
        {
            residences = default(GL.Enums.Boolean*);
                {
                    GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures, (GL.Enums.Boolean*)residences);
                    return retval;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe GLboolean AreTexturesResident(GLsizei n, GLuint* textures, GL.Enums.Boolean* residences)
        {
            unsafe { return Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures, (GL.Enums.Boolean*)residences); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe GLboolean AreTexturesResident(GLsizei n, Int32[] textures, GL.Enums.Boolean* residences)
        {
            residences = default(GL.Enums.Boolean*);
                fixed (Int32* textures_ptr = textures)
                {
                    GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
                    return retval;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, GL.Enums.Boolean* residences)
        {
            residences = default(GL.Enums.Boolean*);
                fixed (GLuint* textures_ptr = textures)
                {
                    GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
                    return retval;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe GLboolean AreTexturesResident(GLsizei n, ref Int32 textures, GL.Enums.Boolean* residences)
        {
            residences = default(GL.Enums.Boolean*);
                fixed (Int32* textures_ptr = &textures)
                {
                    GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
                    return retval;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe GLboolean AreTexturesResident(GLsizei n, ref GLuint textures, GL.Enums.Boolean* residences)
        {
            residences = default(GL.Enums.Boolean*);
                fixed (GLuint* textures_ptr = &textures)
                {
                    GLboolean retval = Delegates.glAreTexturesResident((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
                    return retval;
                }
        }
        
        public static 
        void BindTexture(GL.Enums.TextureTarget target, Int32 texture)
        {
            Delegates.glBindTexture((GL.Enums.TextureTarget)target, (GLuint)texture);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void BindTexture(GL.Enums.TextureTarget target, GLuint texture)
        {
            Delegates.glBindTexture((GL.Enums.TextureTarget)target, (GLuint)texture);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteTextures(GLsizei n, Int32* textures)
        {
                {
                    Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteTextures(GLsizei n, GLuint* textures)
        {
            unsafe { Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures); }
        }
        
        public static 
        void DeleteTextures(GLsizei n, Int32[] textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteTextures(GLsizei n, GLuint[] textures)
        {
            unsafe
            {
                fixed (GLuint* textures_ptr = textures)
                {
                    Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures_ptr);
                }
            }
        }
        
        public static 
        void DeleteTextures(GLsizei n, ref Int32 textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteTextures(GLsizei n, ref GLuint textures)
        {
            unsafe
            {
                fixed (GLuint* textures_ptr = &textures)
                {
                    Delegates.glDeleteTextures((GLsizei)n, (GLuint*)textures_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GenTextures(GLsizei n, Int32* textures)
        {
            textures = default(Int32*);
                {
                    Delegates.glGenTextures((GLsizei)n, (GLuint*)textures);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GenTextures(GLsizei n, GLuint* textures)
        {
            unsafe { Delegates.glGenTextures((GLsizei)n, (GLuint*)textures); }
        }
        
        public static 
        void GenTextures(GLsizei n, Int32[] textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glGenTextures((GLsizei)n, (GLuint*)textures_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GenTextures(GLsizei n, GLuint[] textures)
        {
            unsafe
            {
                fixed (GLuint* textures_ptr = textures)
                {
                    Delegates.glGenTextures((GLsizei)n, (GLuint*)textures_ptr);
                }
            }
        }
        
        public static 
        void GenTextures(GLsizei n, out Int32 textures)
        {
            textures = default(Int32);
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glGenTextures((GLsizei)n, (GLuint*)textures_ptr);
                    textures = *textures_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GenTextures(GLsizei n, out GLuint textures)
        {
            textures = default(GLuint);
            unsafe
            {
                fixed (GLuint* textures_ptr = &textures)
                {
                    Delegates.glGenTextures((GLsizei)n, (GLuint*)textures_ptr);
                    textures = *textures_ptr;
                }
            }
        }
        
        public static 
        GLboolean IsTexture(Int32 texture)
        {
            return Delegates.glIsTexture((GLuint)texture);
        }
        
        [System.CLSCompliant(false)]
        public static 
        GLboolean IsTexture(GLuint texture)
        {
            return Delegates.glIsTexture((GLuint)texture);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, Int32* textures, GLclampf* priorities)
        {
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, GLclampf* priorities)
        {
            unsafe { Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, Int32* textures, GLclampf[] priorities)
        {
                fixed (GLclampf* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, GLclampf[] priorities)
        {
                fixed (GLclampf* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, Int32* textures, ref GLclampf priorities)
        {
                fixed (GLclampf* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, ref GLclampf priorities)
        {
                fixed (GLclampf* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, Int32[] textures, GLclampf* priorities)
        {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf* priorities)
        {
                fixed (GLuint* textures_ptr = textures)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
                }
        }
        
        public static 
        void PrioritizeTextures(GLsizei n, Int32[] textures, GLclampf[] priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (GLclampf* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf[] priorities)
        {
            unsafe
            {
                fixed (GLuint* textures_ptr = textures)
                fixed (GLclampf* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                }
            }
        }
        
        public static 
        void PrioritizeTextures(GLsizei n, Int32[] textures, ref GLclampf priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (GLclampf* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PrioritizeTextures(GLsizei n, GLuint[] textures, ref GLclampf priorities)
        {
            unsafe
            {
                fixed (GLuint* textures_ptr = textures)
                fixed (GLclampf* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, ref Int32 textures, GLclampf* priorities)
        {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf* priorities)
        {
                fixed (GLuint* textures_ptr = &textures)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
                }
        }
        
        public static 
        void PrioritizeTextures(GLsizei n, ref Int32 textures, GLclampf[] priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (GLclampf* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf[] priorities)
        {
            unsafe
            {
                fixed (GLuint* textures_ptr = &textures)
                fixed (GLclampf* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                }
            }
        }
        
        public static 
        void PrioritizeTextures(GLsizei n, ref Int32 textures, ref GLclampf priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (GLclampf* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void PrioritizeTextures(GLsizei n, ref GLuint textures, ref GLclampf priorities)
        {
            unsafe
            {
                fixed (GLuint* textures_ptr = &textures)
                fixed (GLclampf* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                }
            }
        }
        
        public static 
        void Indexub(GLubyte c)
        {
            Delegates.glIndexub((GLubyte)c);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexubv(GLubyte* c)
        {
            unsafe { Delegates.glIndexubv((GLubyte*)c); }
        }
        
        public static 
        void Indexubv(GLubyte[] c)
        {
            unsafe
            {
                fixed (GLubyte* c_ptr = c)
                {
                    Delegates.glIndexubv((GLubyte*)c_ptr);
                }
            }
        }
        
        public static 
        void Indexubv(ref GLubyte c)
        {
            unsafe
            {
                fixed (GLubyte* c_ptr = &c)
                {
                    Delegates.glIndexubv((GLubyte*)c_ptr);
                }
            }
        }
        
        public static 
        void PopClientAttrib()
        {
            Delegates.glPopClientAttrib();
        }
        
        public static 
        void PushClientAttrib(GL.Enums.ClientAttribMask mask)
        {
            Delegates.glPushClientAttrib((GL.Enums.ClientAttribMask)mask);
        }
        
        public static 
        void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
        {
            Delegates.glBlendColor((GLclampf)red, (GLclampf)green, (GLclampf)blue, (GLclampf)alpha);
        }
        
        public static 
        void BlendEquation(GL.Enums.VERSION_1_2 mode)
        {
            Delegates.glBlendEquation((GL.Enums.VERSION_1_2)mode);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count, GL.Enums.VERSION_1_2 type, void* indices)
        {
                {
                    Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.VERSION_1_2)type, (void*)indices);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DrawRangeElements(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GL.Enums.VERSION_1_2 type, void* indices)
        {
            unsafe { Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.VERSION_1_2)type, (void*)indices); }
        }
        
        public static 
        void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count, GL.Enums.VERSION_1_2 type, object indices)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.VERSION_1_2)type, (void*)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DrawRangeElements(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GL.Enums.VERSION_1_2 type, object indices)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glDrawRangeElements((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.VERSION_1_2)type, (void*)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
        {
            unsafe { Delegates.glColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
        }
        
        public static 
        void ColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
        {
            System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
        {
            unsafe { Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
        }
        
        public static 
        void ColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void ColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
        {
            unsafe { Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
        }
        
        public static 
        void ColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void ColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void CopyColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
        {
            Delegates.glCopyColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
        {
            unsafe { Delegates.glGetColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
        }
        
        public static 
        void GetColorTable(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
        {
            System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetColorTable((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetColorTableParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
        {
            unsafe { Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
        }
        
        public static 
        void GetColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetColorTableParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ColorSubTable(GL.Enums.VERSION_1_2 target, GLsizei start, GLsizei count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* data)
        {
            unsafe { Delegates.glColorSubTable((GL.Enums.VERSION_1_2)target, (GLsizei)start, (GLsizei)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
        }
        
        public static 
        void ColorSubTable(GL.Enums.VERSION_1_2 target, GLsizei start, GLsizei count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glColorSubTable((GL.Enums.VERSION_1_2)target, (GLsizei)start, (GLsizei)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        public static 
        void CopyColorSubTable(GL.Enums.VERSION_1_2 target, GLsizei start, GLint x, GLint y, GLsizei width)
        {
            Delegates.glCopyColorSubTable((GL.Enums.VERSION_1_2)target, (GLsizei)start, (GLint)x, (GLint)y, (GLsizei)width);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ConvolutionFilter1D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
        {
            unsafe { Delegates.glConvolutionFilter1D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
        }
        
        public static 
        void ConvolutionFilter1D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
        {
            System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glConvolutionFilter1D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ConvolutionFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
        {
            unsafe { Delegates.glConvolutionFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
        }
        
        public static 
        void ConvolutionFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
        {
            System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glConvolutionFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }
        
        public static 
        void ConvolutionParameterf(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat @params)
        {
            Delegates.glConvolutionParameterf((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat)@params);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
        {
            unsafe { Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
        }
        
        public static 
        void ConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void ConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void ConvolutionParameteri(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint @params)
        {
            Delegates.glConvolutionParameteri((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint)@params);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
        {
            unsafe { Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
        }
        
        public static 
        void ConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void ConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void CopyConvolutionFilter1D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
        {
            Delegates.glCopyConvolutionFilter1D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width);
        }
        
        public static 
        void CopyConvolutionFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
        {
            Delegates.glCopyConvolutionFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetConvolutionFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
        {
            unsafe { Delegates.glGetConvolutionFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
        }
        
        public static 
        void GetConvolutionFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
        {
            System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetConvolutionFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetConvolutionParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetConvolutionParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
        {
            unsafe { Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
        }
        
        public static 
        void GetConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetConvolutionParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetConvolutionParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column, void* span)
        {
            unsafe { Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column, (void*)span); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column, object span)
        {
            row = default(void*);
            column = default(void*);
            System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column, (void*)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    span_ptr.Free();
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column, void* span)
        {
            row = default(void*);
            span = default(void*);
            System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject(), (void*)span);
                }
                finally
                {
                    column_ptr.Free();
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column, object span)
        {
            row = default(void*);
            System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, 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((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject(), (void*)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    column_ptr.Free();
                    span_ptr.Free();
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column, void* span)
        {
            column = default(void*);
            span = default(void*);
            System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column, (void*)span);
                }
                finally
                {
                    row_ptr.Free();
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column, object span)
        {
            column = default(void*);
            System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
            System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column, (void*)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    span_ptr.Free();
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column, void* span)
        {
            span = default(void*);
            System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
            System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject(), (void*)span);
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                }
        }
        
        public static 
        void GetSeparableFilter(GL.Enums.VERSION_1_2 target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column, object span)
        {
            System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, 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 row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetSeparableFilter((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject(), (void*)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                    span_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SeparableFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column)
        {
            unsafe { Delegates.glSeparableFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SeparableFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column)
        {
            System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    column_ptr.Free();
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SeparableFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column)
        {
            System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column);
                }
                finally
                {
                    row_ptr.Free();
                }
        }
        
        public static 
        void SeparableFilter2D(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column)
        {
            System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
            System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glSeparableFilter2D((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetHistogram(GL.Enums.VERSION_1_2 target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* values)
        {
            unsafe { Delegates.glGetHistogram((GL.Enums.VERSION_1_2)target, (GL.Enums.Boolean)reset, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)values); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetHistogramParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetHistogramParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetHistogramParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetHistogramParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetHistogramParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
        {
            unsafe { Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
        }
        
        public static 
        void GetHistogramParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetHistogramParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetHistogramParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMinmax(GL.Enums.VERSION_1_2 target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* values)
        {
            unsafe { Delegates.glGetMinmax((GL.Enums.VERSION_1_2)target, (GL.Enums.Boolean)reset, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)values); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMinmaxParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetMinmaxParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetMinmaxParameterfv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetMinmaxParameterfv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMinmaxParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint* @params)
        {
            unsafe { Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params); }
        }
        
        public static 
        void GetMinmaxParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetMinmaxParameteriv(GL.Enums.VERSION_1_2 target, GL.Enums.VERSION_1_2 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetMinmaxParameteriv((GL.Enums.VERSION_1_2)target, (GL.Enums.VERSION_1_2)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        public static 
        void Histogram(GL.Enums.VERSION_1_2 target, GLsizei width, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
        {
             Delegates.glHistogram((GL.Enums.VERSION_1_2)target, (GLsizei)width, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink); 
        }
        
        public static 
        void Minmax(GL.Enums.VERSION_1_2 target, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
        {
             Delegates.glMinmax((GL.Enums.VERSION_1_2)target, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink); 
        }
        
        public static 
        void ResetHistogram(GL.Enums.VERSION_1_2 target)
        {
            Delegates.glResetHistogram((GL.Enums.VERSION_1_2)target);
        }
        
        public static 
        void ResetMinmax(GL.Enums.VERSION_1_2 target)
        {
            Delegates.glResetMinmax((GL.Enums.VERSION_1_2)target);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexImage3D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glTexImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void TexImage3D(GL.Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glTexImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
        {
            unsafe { Delegates.glTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
        }
        
        public static 
        void TexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }
        
        public static 
        void CopyTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
        {
            Delegates.glCopyTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
        }
        
        public static 
        void ActiveTexture(GL.Enums.VERSION_1_3 texture)
        {
            Delegates.glActiveTexture((GL.Enums.VERSION_1_3)texture);
        }
        
        public static 
        void ClientActiveTexture(GL.Enums.VERSION_1_3 texture)
        {
            Delegates.glClientActiveTexture((GL.Enums.VERSION_1_3)texture);
        }
        
        public static 
        void MultiTexCoord1d(GL.Enums.VERSION_1_3 target, GLdouble s)
        {
            Delegates.glMultiTexCoord1d((GL.Enums.VERSION_1_3)target, (GLdouble)s);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord1dv(GL.Enums.VERSION_1_3 target, GLdouble* v)
        {
            unsafe { Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v); }
        }
        
        public static 
        void MultiTexCoord1dv(GL.Enums.VERSION_1_3 target, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord1dv(GL.Enums.VERSION_1_3 target, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord1f(GL.Enums.VERSION_1_3 target, GLfloat s)
        {
            Delegates.glMultiTexCoord1f((GL.Enums.VERSION_1_3)target, (GLfloat)s);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord1fv(GL.Enums.VERSION_1_3 target, GLfloat* v)
        {
            unsafe { Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v); }
        }
        
        public static 
        void MultiTexCoord1fv(GL.Enums.VERSION_1_3 target, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord1fv(GL.Enums.VERSION_1_3 target, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord1i(GL.Enums.VERSION_1_3 target, GLint s)
        {
            Delegates.glMultiTexCoord1i((GL.Enums.VERSION_1_3)target, (GLint)s);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord1iv(GL.Enums.VERSION_1_3 target, GLint* v)
        {
            unsafe { Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (GLint*)v); }
        }
        
        public static 
        void MultiTexCoord1iv(GL.Enums.VERSION_1_3 target, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord1iv(GL.Enums.VERSION_1_3 target, ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord1s(GL.Enums.VERSION_1_3 target, GLshort s)
        {
            Delegates.glMultiTexCoord1s((GL.Enums.VERSION_1_3)target, (GLshort)s);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord1sv(GL.Enums.VERSION_1_3 target, GLshort* v)
        {
            unsafe { Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (GLshort*)v); }
        }
        
        public static 
        void MultiTexCoord1sv(GL.Enums.VERSION_1_3 target, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord1sv(GL.Enums.VERSION_1_3 target, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord2d(GL.Enums.VERSION_1_3 target, GLdouble s, GLdouble t)
        {
            Delegates.glMultiTexCoord2d((GL.Enums.VERSION_1_3)target, (GLdouble)s, (GLdouble)t);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord2dv(GL.Enums.VERSION_1_3 target, GLdouble* v)
        {
            unsafe { Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v); }
        }
        
        public static 
        void MultiTexCoord2dv(GL.Enums.VERSION_1_3 target, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord2dv(GL.Enums.VERSION_1_3 target, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord2f(GL.Enums.VERSION_1_3 target, GLfloat s, GLfloat t)
        {
            Delegates.glMultiTexCoord2f((GL.Enums.VERSION_1_3)target, (GLfloat)s, (GLfloat)t);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord2fv(GL.Enums.VERSION_1_3 target, GLfloat* v)
        {
            unsafe { Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v); }
        }
        
        public static 
        void MultiTexCoord2fv(GL.Enums.VERSION_1_3 target, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord2fv(GL.Enums.VERSION_1_3 target, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord2i(GL.Enums.VERSION_1_3 target, GLint s, GLint t)
        {
            Delegates.glMultiTexCoord2i((GL.Enums.VERSION_1_3)target, (GLint)s, (GLint)t);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord2iv(GL.Enums.VERSION_1_3 target, GLint* v)
        {
            unsafe { Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (GLint*)v); }
        }
        
        public static 
        void MultiTexCoord2iv(GL.Enums.VERSION_1_3 target, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord2iv(GL.Enums.VERSION_1_3 target, ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord2s(GL.Enums.VERSION_1_3 target, GLshort s, GLshort t)
        {
            Delegates.glMultiTexCoord2s((GL.Enums.VERSION_1_3)target, (GLshort)s, (GLshort)t);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord2sv(GL.Enums.VERSION_1_3 target, GLshort* v)
        {
            unsafe { Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (GLshort*)v); }
        }
        
        public static 
        void MultiTexCoord2sv(GL.Enums.VERSION_1_3 target, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord2sv(GL.Enums.VERSION_1_3 target, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord3d(GL.Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r)
        {
            Delegates.glMultiTexCoord3d((GL.Enums.VERSION_1_3)target, (GLdouble)s, (GLdouble)t, (GLdouble)r);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord3dv(GL.Enums.VERSION_1_3 target, GLdouble* v)
        {
            unsafe { Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v); }
        }
        
        public static 
        void MultiTexCoord3dv(GL.Enums.VERSION_1_3 target, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord3dv(GL.Enums.VERSION_1_3 target, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord3f(GL.Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r)
        {
            Delegates.glMultiTexCoord3f((GL.Enums.VERSION_1_3)target, (GLfloat)s, (GLfloat)t, (GLfloat)r);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord3fv(GL.Enums.VERSION_1_3 target, GLfloat* v)
        {
            unsafe { Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v); }
        }
        
        public static 
        void MultiTexCoord3fv(GL.Enums.VERSION_1_3 target, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord3fv(GL.Enums.VERSION_1_3 target, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord3i(GL.Enums.VERSION_1_3 target, GLint s, GLint t, GLint r)
        {
            Delegates.glMultiTexCoord3i((GL.Enums.VERSION_1_3)target, (GLint)s, (GLint)t, (GLint)r);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord3iv(GL.Enums.VERSION_1_3 target, GLint* v)
        {
            unsafe { Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (GLint*)v); }
        }
        
        public static 
        void MultiTexCoord3iv(GL.Enums.VERSION_1_3 target, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord3iv(GL.Enums.VERSION_1_3 target, ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord3s(GL.Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r)
        {
            Delegates.glMultiTexCoord3s((GL.Enums.VERSION_1_3)target, (GLshort)s, (GLshort)t, (GLshort)r);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord3sv(GL.Enums.VERSION_1_3 target, GLshort* v)
        {
            unsafe { Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (GLshort*)v); }
        }
        
        public static 
        void MultiTexCoord3sv(GL.Enums.VERSION_1_3 target, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord3sv(GL.Enums.VERSION_1_3 target, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord4d(GL.Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
        {
            Delegates.glMultiTexCoord4d((GL.Enums.VERSION_1_3)target, (GLdouble)s, (GLdouble)t, (GLdouble)r, (GLdouble)q);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord4dv(GL.Enums.VERSION_1_3 target, GLdouble* v)
        {
            unsafe { Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v); }
        }
        
        public static 
        void MultiTexCoord4dv(GL.Enums.VERSION_1_3 target, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord4dv(GL.Enums.VERSION_1_3 target, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4dv((GL.Enums.VERSION_1_3)target, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord4f(GL.Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
        {
            Delegates.glMultiTexCoord4f((GL.Enums.VERSION_1_3)target, (GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)q);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord4fv(GL.Enums.VERSION_1_3 target, GLfloat* v)
        {
            unsafe { Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v); }
        }
        
        public static 
        void MultiTexCoord4fv(GL.Enums.VERSION_1_3 target, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord4fv(GL.Enums.VERSION_1_3 target, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4fv((GL.Enums.VERSION_1_3)target, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord4i(GL.Enums.VERSION_1_3 target, GLint s, GLint t, GLint r, GLint q)
        {
            Delegates.glMultiTexCoord4i((GL.Enums.VERSION_1_3)target, (GLint)s, (GLint)t, (GLint)r, (GLint)q);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord4iv(GL.Enums.VERSION_1_3 target, GLint* v)
        {
            unsafe { Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (GLint*)v); }
        }
        
        public static 
        void MultiTexCoord4iv(GL.Enums.VERSION_1_3 target, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord4iv(GL.Enums.VERSION_1_3 target, ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4iv((GL.Enums.VERSION_1_3)target, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord4s(GL.Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r, GLshort q)
        {
            Delegates.glMultiTexCoord4s((GL.Enums.VERSION_1_3)target, (GLshort)s, (GLshort)t, (GLshort)r, (GLshort)q);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord4sv(GL.Enums.VERSION_1_3 target, GLshort* v)
        {
            unsafe { Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (GLshort*)v); }
        }
        
        public static 
        void MultiTexCoord4sv(GL.Enums.VERSION_1_3 target, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void MultiTexCoord4sv(GL.Enums.VERSION_1_3 target, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4sv((GL.Enums.VERSION_1_3)target, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void LoadTransposeMatrixf(GLfloat* m)
        {
            unsafe { Delegates.glLoadTransposeMatrixf((GLfloat*)m); }
        }
        
        public static 
        void LoadTransposeMatrixf(GLfloat[] m)
        {
            unsafe
            {
                fixed (GLfloat* m_ptr = m)
                {
                    Delegates.glLoadTransposeMatrixf((GLfloat*)m_ptr);
                }
            }
        }
        
        public static 
        void LoadTransposeMatrixf(ref GLfloat m)
        {
            unsafe
            {
                fixed (GLfloat* m_ptr = &m)
                {
                    Delegates.glLoadTransposeMatrixf((GLfloat*)m_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void LoadTransposeMatrixd(GLdouble* m)
        {
            unsafe { Delegates.glLoadTransposeMatrixd((GLdouble*)m); }
        }
        
        public static 
        void LoadTransposeMatrixd(GLdouble[] m)
        {
            unsafe
            {
                fixed (GLdouble* m_ptr = m)
                {
                    Delegates.glLoadTransposeMatrixd((GLdouble*)m_ptr);
                }
            }
        }
        
        public static 
        void LoadTransposeMatrixd(ref GLdouble m)
        {
            unsafe
            {
                fixed (GLdouble* m_ptr = &m)
                {
                    Delegates.glLoadTransposeMatrixd((GLdouble*)m_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultTransposeMatrixf(GLfloat* m)
        {
            unsafe { Delegates.glMultTransposeMatrixf((GLfloat*)m); }
        }
        
        public static 
        void MultTransposeMatrixf(GLfloat[] m)
        {
            unsafe
            {
                fixed (GLfloat* m_ptr = m)
                {
                    Delegates.glMultTransposeMatrixf((GLfloat*)m_ptr);
                }
            }
        }
        
        public static 
        void MultTransposeMatrixf(ref GLfloat m)
        {
            unsafe
            {
                fixed (GLfloat* m_ptr = &m)
                {
                    Delegates.glMultTransposeMatrixf((GLfloat*)m_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultTransposeMatrixd(GLdouble* m)
        {
            unsafe { Delegates.glMultTransposeMatrixd((GLdouble*)m); }
        }
        
        public static 
        void MultTransposeMatrixd(GLdouble[] m)
        {
            unsafe
            {
                fixed (GLdouble* m_ptr = m)
                {
                    Delegates.glMultTransposeMatrixd((GLdouble*)m_ptr);
                }
            }
        }
        
        public static 
        void MultTransposeMatrixd(ref GLdouble m)
        {
            unsafe
            {
                fixed (GLdouble* m_ptr = &m)
                {
                    Delegates.glMultTransposeMatrixd((GLdouble*)m_ptr);
                }
            }
        }
        
        public static 
        void SampleCoverage(GLclampf value, GL.Enums.Boolean invert)
        {
             Delegates.glSampleCoverage((GLclampf)value, (GL.Enums.Boolean)invert); 
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void CompressedTexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, void* data)
        {
            unsafe { Delegates.glCompressedTexImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GLsizei)imageSize, (void*)data); }
        }
        
        public static 
        void CompressedTexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glCompressedTexImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void CompressedTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, void* data)
        {
            unsafe { Delegates.glCompressedTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLsizei)imageSize, (void*)data); }
        }
        
        public static 
        void CompressedTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glCompressedTexImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void CompressedTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, void* data)
        {
            unsafe { Delegates.glCompressedTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLint)border, (GLsizei)imageSize, (void*)data); }
        }
        
        public static 
        void CompressedTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glCompressedTexImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void CompressedTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
        {
            unsafe { Delegates.glCompressedTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
        }
        
        public static 
        void CompressedTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glCompressedTexSubImage3D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void CompressedTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
        {
            unsafe { Delegates.glCompressedTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
        }
        
        public static 
        void CompressedTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glCompressedTexSubImage2D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void CompressedTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
        {
            unsafe { Delegates.glCompressedTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
        }
        
        public static 
        void CompressedTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glCompressedTexSubImage1D((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetCompressedTexImage(GL.Enums.TextureTarget target, GLint level, void* img)
        {
            unsafe { Delegates.glGetCompressedTexImage((GL.Enums.TextureTarget)target, (GLint)level, (void*)img); }
        }
        
        public static 
        void GetCompressedTexImage(GL.Enums.TextureTarget target, GLint level, object img)
        {
            System.Runtime.InteropServices.GCHandle img_ptr = System.Runtime.InteropServices.GCHandle.Alloc(img, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetCompressedTexImage((GL.Enums.TextureTarget)target, (GLint)level, (void*)img_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    img_ptr.Free();
                }
            }
        }
        
        public static 
        void BlendFuncSeparate(GL.Enums.VERSION_1_4 sfactorRGB, GL.Enums.VERSION_1_4 dfactorRGB, GL.Enums.VERSION_1_4 sfactorAlpha, GL.Enums.VERSION_1_4 dfactorAlpha)
        {
            Delegates.glBlendFuncSeparate((GL.Enums.VERSION_1_4)sfactorRGB, (GL.Enums.VERSION_1_4)dfactorRGB, (GL.Enums.VERSION_1_4)sfactorAlpha, (GL.Enums.VERSION_1_4)dfactorAlpha);
        }
        
        public static 
        void FogCoordf(GLfloat coord)
        {
            Delegates.glFogCoordf((GLfloat)coord);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void FogCoordfv(GLfloat* coord)
        {
            unsafe { Delegates.glFogCoordfv((GLfloat*)coord); }
        }
        
        public static 
        void FogCoordfv(GLfloat[] coord)
        {
            unsafe
            {
                fixed (GLfloat* coord_ptr = coord)
                {
                    Delegates.glFogCoordfv((GLfloat*)coord_ptr);
                }
            }
        }
        
        public static 
        void FogCoordfv(ref GLfloat coord)
        {
            unsafe
            {
                fixed (GLfloat* coord_ptr = &coord)
                {
                    Delegates.glFogCoordfv((GLfloat*)coord_ptr);
                }
            }
        }
        
        public static 
        void FogCoordd(GLdouble coord)
        {
            Delegates.glFogCoordd((GLdouble)coord);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void FogCoorddv(GLdouble* coord)
        {
            unsafe { Delegates.glFogCoorddv((GLdouble*)coord); }
        }
        
        public static 
        void FogCoorddv(GLdouble[] coord)
        {
            unsafe
            {
                fixed (GLdouble* coord_ptr = coord)
                {
                    Delegates.glFogCoorddv((GLdouble*)coord_ptr);
                }
            }
        }
        
        public static 
        void FogCoorddv(ref GLdouble coord)
        {
            unsafe
            {
                fixed (GLdouble* coord_ptr = &coord)
                {
                    Delegates.glFogCoorddv((GLdouble*)coord_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void FogCoordPointer(GL.Enums.VERSION_1_4 type, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glFogCoordPointer((GL.Enums.VERSION_1_4)type, (GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void FogCoordPointer(GL.Enums.VERSION_1_4 type, GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glFogCoordPointer((GL.Enums.VERSION_1_4)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, GLsizei* count, GLsizei primcount)
        {
            unsafe { Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count, (GLsizei)primcount); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, GLsizei[] count, GLsizei primcount)
        {
            first = default(GLint*);
                fixed (GLsizei* count_ptr = count)
                {
                    Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, out GLsizei count, GLsizei primcount)
        {
            first = default(GLint*);
            count = default(GLsizei);
                fixed (GLsizei* count_ptr = &count)
                {
                    Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                    count = *count_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, GLsizei* count, GLsizei primcount)
        {
            count = default(GLsizei*);
                fixed (GLint* first_ptr = first)
                {
                    Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                }
        }
        
        public static 
        void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
        {
            unsafe
            {
                fixed (GLint* first_ptr = first)
                fixed (GLsizei* count_ptr = count)
                {
                    Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                }
            }
        }
        
        public static 
        void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, out GLsizei count, GLsizei primcount)
        {
            count = default(GLsizei);
            unsafe
            {
                fixed (GLint* first_ptr = first)
                fixed (GLsizei* count_ptr = &count)
                {
                    Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    count = *count_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, GLsizei* count, GLsizei primcount)
        {
            first = default(GLint);
            count = default(GLsizei*);
                fixed (GLint* first_ptr = &first)
                {
                    Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                    first = *first_ptr;
                }
        }
        
        public static 
        void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, GLsizei[] count, GLsizei primcount)
        {
            first = default(GLint);
            unsafe
            {
                fixed (GLint* first_ptr = &first)
                fixed (GLsizei* count_ptr = count)
                {
                    Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    first = *first_ptr;
                }
            }
        }
        
        public static 
        void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, out GLsizei count, GLsizei primcount)
        {
            first = default(GLint);
            count = default(GLsizei);
            unsafe
            {
                fixed (GLint* first_ptr = &first)
                fixed (GLsizei* count_ptr = &count)
                {
                    Delegates.glMultiDrawArrays((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    first = *first_ptr;
                    count = *count_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.VERSION_1_4 type, void* indices, GLsizei primcount)
        {
            unsafe { Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count, (GL.Enums.VERSION_1_4)type, (void*)indices, (GLsizei)primcount); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.VERSION_1_4 type, object indices, GLsizei primcount)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
                }
                finally
                {
                    indices_ptr.Free();
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.VERSION_1_4 type, void* indices, GLsizei primcount)
        {
                fixed (GLsizei* count_ptr = count)
                {
                    Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices, (GLsizei)primcount);
                }
        }
        
        public static 
        void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.VERSION_1_4 type, object indices, GLsizei primcount)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                fixed (GLsizei* count_ptr = count)
                try
                {
                    Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawElements(GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.VERSION_1_4 type, void* indices, GLsizei primcount)
        {
                fixed (GLsizei* count_ptr = &count)
                {
                    Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices, (GLsizei)primcount);
                }
        }
        
        public static 
        void MultiDrawElements(GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.VERSION_1_4 type, object indices, GLsizei primcount)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                fixed (GLsizei* count_ptr = &count)
                try
                {
                    Delegates.glMultiDrawElements((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.VERSION_1_4)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }
        
        public static 
        void PointParameterf(GL.Enums.VERSION_1_4 pname, GLfloat param)
        {
            Delegates.glPointParameterf((GL.Enums.VERSION_1_4)pname, (GLfloat)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PointParameterfv(GL.Enums.VERSION_1_4 pname, GLfloat* @params)
        {
            unsafe { Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (GLfloat*)@params); }
        }
        
        public static 
        void PointParameterfv(GL.Enums.VERSION_1_4 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void PointParameterfv(GL.Enums.VERSION_1_4 pname, ref GLfloat @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glPointParameterfv((GL.Enums.VERSION_1_4)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void PointParameteri(GL.Enums.VERSION_1_4 pname, GLint param)
        {
            Delegates.glPointParameteri((GL.Enums.VERSION_1_4)pname, (GLint)param);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void PointParameteriv(GL.Enums.VERSION_1_4 pname, GLint* @params)
        {
            unsafe { Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (GLint*)@params); }
        }
        
        public static 
        void PointParameteriv(GL.Enums.VERSION_1_4 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void PointParameteriv(GL.Enums.VERSION_1_4 pname, ref GLint @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glPointParameteriv((GL.Enums.VERSION_1_4)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3b(Byte red, Byte green, Byte blue)
        {
            Delegates.glSecondaryColor3b((GLbyte)red, (GLbyte)green, (GLbyte)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
        {
            Delegates.glSecondaryColor3b((GLbyte)red, (GLbyte)green, (GLbyte)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3bv(Byte* v)
        {
                {
                    Delegates.glSecondaryColor3bv((GLbyte*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3bv(GLbyte* v)
        {
            unsafe { Delegates.glSecondaryColor3bv((GLbyte*)v); }
        }
        
        public static 
        void SecondaryColor3bv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3bv(GLbyte[] v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3bv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3bv(ref GLbyte v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3bv((GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
        {
            Delegates.glSecondaryColor3d((GLdouble)red, (GLdouble)green, (GLdouble)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3dv(GLdouble* v)
        {
            unsafe { Delegates.glSecondaryColor3dv((GLdouble*)v); }
        }
        
        public static 
        void SecondaryColor3dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glSecondaryColor3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
        {
            Delegates.glSecondaryColor3f((GLfloat)red, (GLfloat)green, (GLfloat)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3fv(GLfloat* v)
        {
            unsafe { Delegates.glSecondaryColor3fv((GLfloat*)v); }
        }
        
        public static 
        void SecondaryColor3fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glSecondaryColor3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3i(GLint red, GLint green, GLint blue)
        {
            Delegates.glSecondaryColor3i((GLint)red, (GLint)green, (GLint)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3iv(GLint* v)
        {
            unsafe { Delegates.glSecondaryColor3iv((GLint*)v); }
        }
        
        public static 
        void SecondaryColor3iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glSecondaryColor3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
        {
            Delegates.glSecondaryColor3s((GLshort)red, (GLshort)green, (GLshort)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3sv(GLshort* v)
        {
            unsafe { Delegates.glSecondaryColor3sv((GLshort*)v); }
        }
        
        public static 
        void SecondaryColor3sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glSecondaryColor3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
        {
            Delegates.glSecondaryColor3ub((GLubyte)red, (GLubyte)green, (GLubyte)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3ubv(GLubyte* v)
        {
            unsafe { Delegates.glSecondaryColor3ubv((GLubyte*)v); }
        }
        
        public static 
        void SecondaryColor3ubv(GLubyte[] v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3ubv((GLubyte*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3ubv(ref GLubyte v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3ubv((GLubyte*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3ui(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glSecondaryColor3ui((GLuint)red, (GLuint)green, (GLuint)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
        {
            Delegates.glSecondaryColor3ui((GLuint)red, (GLuint)green, (GLuint)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3uiv(Int32* v)
        {
                {
                    Delegates.glSecondaryColor3uiv((GLuint*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3uiv(GLuint* v)
        {
            unsafe { Delegates.glSecondaryColor3uiv((GLuint*)v); }
        }
        
        public static 
        void SecondaryColor3uiv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3uiv((GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3uiv(GLuint[] v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = v)
                {
                    Delegates.glSecondaryColor3uiv((GLuint*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3uiv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3uiv((GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3uiv(ref GLuint v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3uiv((GLuint*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3us(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glSecondaryColor3us((GLushort)red, (GLushort)green, (GLushort)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3us(GLushort red, GLushort green, GLushort blue)
        {
            Delegates.glSecondaryColor3us((GLushort)red, (GLushort)green, (GLushort)blue);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3usv(Int16* v)
        {
                {
                    Delegates.glSecondaryColor3usv((GLushort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3usv(GLushort* v)
        {
            unsafe { Delegates.glSecondaryColor3usv((GLushort*)v); }
        }
        
        public static 
        void SecondaryColor3usv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3usv((GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3usv(GLushort[] v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = v)
                {
                    Delegates.glSecondaryColor3usv((GLushort*)v_ptr);
                }
            }
        }
        
        public static 
        void SecondaryColor3usv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3usv((GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3usv(ref GLushort v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3usv((GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glSecondaryColorPointer((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer); }
        }
        
        public static 
        void SecondaryColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glSecondaryColorPointer((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        public static 
        void WindowPos2d(GLdouble x, GLdouble y)
        {
            Delegates.glWindowPos2d((GLdouble)x, (GLdouble)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos2dv(GLdouble* v)
        {
            unsafe { Delegates.glWindowPos2dv((GLdouble*)v); }
        }
        
        public static 
        void WindowPos2dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glWindowPos2dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos2dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glWindowPos2dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos2f(GLfloat x, GLfloat y)
        {
            Delegates.glWindowPos2f((GLfloat)x, (GLfloat)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos2fv(GLfloat* v)
        {
            unsafe { Delegates.glWindowPos2fv((GLfloat*)v); }
        }
        
        public static 
        void WindowPos2fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glWindowPos2fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos2fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glWindowPos2fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos2i(GLint x, GLint y)
        {
            Delegates.glWindowPos2i((GLint)x, (GLint)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos2iv(GLint* v)
        {
            unsafe { Delegates.glWindowPos2iv((GLint*)v); }
        }
        
        public static 
        void WindowPos2iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glWindowPos2iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos2iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glWindowPos2iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos2s(GLshort x, GLshort y)
        {
            Delegates.glWindowPos2s((GLshort)x, (GLshort)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos2sv(GLshort* v)
        {
            unsafe { Delegates.glWindowPos2sv((GLshort*)v); }
        }
        
        public static 
        void WindowPos2sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glWindowPos2sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos2sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glWindowPos2sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
        {
            Delegates.glWindowPos3d((GLdouble)x, (GLdouble)y, (GLdouble)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos3dv(GLdouble* v)
        {
            unsafe { Delegates.glWindowPos3dv((GLdouble*)v); }
        }
        
        public static 
        void WindowPos3dv(GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glWindowPos3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos3dv(ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glWindowPos3dv((GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
        {
            Delegates.glWindowPos3f((GLfloat)x, (GLfloat)y, (GLfloat)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos3fv(GLfloat* v)
        {
            unsafe { Delegates.glWindowPos3fv((GLfloat*)v); }
        }
        
        public static 
        void WindowPos3fv(GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glWindowPos3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos3fv(ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glWindowPos3fv((GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos3i(GLint x, GLint y, GLint z)
        {
            Delegates.glWindowPos3i((GLint)x, (GLint)y, (GLint)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos3iv(GLint* v)
        {
            unsafe { Delegates.glWindowPos3iv((GLint*)v); }
        }
        
        public static 
        void WindowPos3iv(GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glWindowPos3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos3iv(ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glWindowPos3iv((GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos3s(GLshort x, GLshort y, GLshort z)
        {
            Delegates.glWindowPos3s((GLshort)x, (GLshort)y, (GLshort)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos3sv(GLshort* v)
        {
            unsafe { Delegates.glWindowPos3sv((GLshort*)v); }
        }
        
        public static 
        void WindowPos3sv(GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glWindowPos3sv((GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void WindowPos3sv(ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glWindowPos3sv((GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GenQueries(GLsizei n, Int32* ids)
        {
            ids = default(Int32*);
                {
                    Delegates.glGenQueries((GLsizei)n, (GLuint*)ids);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GenQueries(GLsizei n, GLuint* ids)
        {
            unsafe { Delegates.glGenQueries((GLsizei)n, (GLuint*)ids); }
        }
        
        public static 
        void GenQueries(GLsizei n, Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glGenQueries((GLsizei)n, (GLuint*)ids_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GenQueries(GLsizei n, GLuint[] ids)
        {
            unsafe
            {
                fixed (GLuint* ids_ptr = ids)
                {
                    Delegates.glGenQueries((GLsizei)n, (GLuint*)ids_ptr);
                }
            }
        }
        
        public static 
        void GenQueries(GLsizei n, out Int32 ids)
        {
            ids = default(Int32);
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glGenQueries((GLsizei)n, (GLuint*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GenQueries(GLsizei n, out GLuint ids)
        {
            ids = default(GLuint);
            unsafe
            {
                fixed (GLuint* ids_ptr = &ids)
                {
                    Delegates.glGenQueries((GLsizei)n, (GLuint*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteQueries(GLsizei n, Int32* ids)
        {
                {
                    Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteQueries(GLsizei n, GLuint* ids)
        {
            unsafe { Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids); }
        }
        
        public static 
        void DeleteQueries(GLsizei n, Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteQueries(GLsizei n, GLuint[] ids)
        {
            unsafe
            {
                fixed (GLuint* ids_ptr = ids)
                {
                    Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids_ptr);
                }
            }
        }
        
        public static 
        void DeleteQueries(GLsizei n, ref Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteQueries(GLsizei n, ref GLuint ids)
        {
            unsafe
            {
                fixed (GLuint* ids_ptr = &ids)
                {
                    Delegates.glDeleteQueries((GLsizei)n, (GLuint*)ids_ptr);
                }
            }
        }
        
        public static 
        GLboolean IsQuery(Int32 id)
        {
            return Delegates.glIsQuery((GLuint)id);
        }
        
        [System.CLSCompliant(false)]
        public static 
        GLboolean IsQuery(GLuint id)
        {
            return Delegates.glIsQuery((GLuint)id);
        }
        
        public static 
        void BeginQuery(GL.Enums.VERSION_1_5 target, Int32 id)
        {
            Delegates.glBeginQuery((GL.Enums.VERSION_1_5)target, (GLuint)id);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void BeginQuery(GL.Enums.VERSION_1_5 target, GLuint id)
        {
            Delegates.glBeginQuery((GL.Enums.VERSION_1_5)target, (GLuint)id);
        }
        
        public static 
        void EndQuery(GL.Enums.VERSION_1_5 target)
        {
            Delegates.glEndQuery((GL.Enums.VERSION_1_5)target);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQueryiv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, GLint* @params)
        {
            unsafe { Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params); }
        }
        
        public static 
        void GetQueryiv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetQueryiv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetQueryiv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQueryObjectiv(Int32 id, GL.Enums.VERSION_1_5 pname, GLint* @params)
        {
            @params = default(GLint*);
                {
                    Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQueryObjectiv(GLuint id, GL.Enums.VERSION_1_5 pname, GLint* @params)
        {
            unsafe { Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params); }
        }
        
        public static 
        void GetQueryObjectiv(Int32 id, GL.Enums.VERSION_1_5 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetQueryObjectiv(GLuint id, GL.Enums.VERSION_1_5 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetQueryObjectiv(Int32 id, GL.Enums.VERSION_1_5 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetQueryObjectiv(GLuint id, GL.Enums.VERSION_1_5 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQueryObjectuiv(Int32 id, GL.Enums.VERSION_1_5 pname, Int32* @params)
        {
            @params = default(Int32*);
                {
                    Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQueryObjectuiv(GLuint id, GL.Enums.VERSION_1_5 pname, GLuint* @params)
        {
            unsafe { Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params); }
        }
        
        public static 
        void GetQueryObjectuiv(Int32 id, GL.Enums.VERSION_1_5 pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetQueryObjectuiv(GLuint id, GL.Enums.VERSION_1_5 pname, GLuint[] @params)
        {
            unsafe
            {
                fixed (GLuint* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetQueryObjectuiv(Int32 id, GL.Enums.VERSION_1_5 pname, out Int32 @params)
        {
            @params = default(Int32);
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetQueryObjectuiv(GLuint id, GL.Enums.VERSION_1_5 pname, out GLuint @params)
        {
            @params = default(GLuint);
            unsafe
            {
                fixed (GLuint* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectuiv((GLuint)id, (GL.Enums.VERSION_1_5)pname, (GLuint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        public static 
        void BindBuffer(GL.Enums.VERSION_1_5 target, Int32 buffer)
        {
            Delegates.glBindBuffer((GL.Enums.VERSION_1_5)target, (GLuint)buffer);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void BindBuffer(GL.Enums.VERSION_1_5 target, GLuint buffer)
        {
            Delegates.glBindBuffer((GL.Enums.VERSION_1_5)target, (GLuint)buffer);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteBuffers(GLsizei n, Int32* buffers)
        {
                {
                    Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteBuffers(GLsizei n, GLuint* buffers)
        {
            unsafe { Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers); }
        }
        
        public static 
        void DeleteBuffers(GLsizei n, Int32[] buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteBuffers(GLsizei n, GLuint[] buffers)
        {
            unsafe
            {
                fixed (GLuint* buffers_ptr = buffers)
                {
                    Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers_ptr);
                }
            }
        }
        
        public static 
        void DeleteBuffers(GLsizei n, ref Int32 buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteBuffers(GLsizei n, ref GLuint buffers)
        {
            unsafe
            {
                fixed (GLuint* buffers_ptr = &buffers)
                {
                    Delegates.glDeleteBuffers((GLsizei)n, (GLuint*)buffers_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GenBuffers(GLsizei n, Int32* buffers)
        {
            buffers = default(Int32*);
                {
                    Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GenBuffers(GLsizei n, GLuint* buffers)
        {
            unsafe { Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers); }
        }
        
        public static 
        void GenBuffers(GLsizei n, Int32[] buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GenBuffers(GLsizei n, GLuint[] buffers)
        {
            unsafe
            {
                fixed (GLuint* buffers_ptr = buffers)
                {
                    Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers_ptr);
                }
            }
        }
        
        public static 
        void GenBuffers(GLsizei n, out Int32 buffers)
        {
            buffers = default(Int32);
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers_ptr);
                    buffers = *buffers_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GenBuffers(GLsizei n, out GLuint buffers)
        {
            buffers = default(GLuint);
            unsafe
            {
                fixed (GLuint* buffers_ptr = &buffers)
                {
                    Delegates.glGenBuffers((GLsizei)n, (GLuint*)buffers_ptr);
                    buffers = *buffers_ptr;
                }
            }
        }
        
        public static 
        GLboolean IsBuffer(Int32 buffer)
        {
            return Delegates.glIsBuffer((GLuint)buffer);
        }
        
        [System.CLSCompliant(false)]
        public static 
        GLboolean IsBuffer(GLuint buffer)
        {
            return Delegates.glIsBuffer((GLuint)buffer);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void BufferData(GL.Enums.VERSION_1_5 target, GLsizeiptr size, void* data, GL.Enums.VERSION_1_5 usage)
        {
            unsafe { Delegates.glBufferData((GL.Enums.VERSION_1_5)target, (GLsizeiptr)size, (void*)data, (GL.Enums.VERSION_1_5)usage); }
        }
        
        public static 
        void BufferData(GL.Enums.VERSION_1_5 target, GLsizeiptr size, object data, GL.Enums.VERSION_1_5 usage)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glBufferData((GL.Enums.VERSION_1_5)target, (GLsizeiptr)size, (void*)data_ptr.AddrOfPinnedObject(), (GL.Enums.VERSION_1_5)usage);
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void BufferSubData(GL.Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, void* data)
        {
            unsafe { Delegates.glBufferSubData((GL.Enums.VERSION_1_5)target, (GLintptr)offset, (GLsizeiptr)size, (void*)data); }
        }
        
        public static 
        void BufferSubData(GL.Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glBufferSubData((GL.Enums.VERSION_1_5)target, (GLintptr)offset, (GLsizeiptr)size, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetBufferSubData(GL.Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, void* data)
        {
            unsafe { Delegates.glGetBufferSubData((GL.Enums.VERSION_1_5)target, (GLintptr)offset, (GLsizeiptr)size, (void*)data); }
        }
        
        public static 
        void GetBufferSubData(GL.Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetBufferSubData((GL.Enums.VERSION_1_5)target, (GLintptr)offset, (GLsizeiptr)size, (void*)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }
        
        public static 
        IntPtr MapBuffer(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 access)
        {
             return Delegates.glMapBuffer((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)access); 
        }
        
        public static 
        GLboolean UnmapBuffer(GL.Enums.VERSION_1_5 target)
        {
            return Delegates.glUnmapBuffer((GL.Enums.VERSION_1_5)target);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetBufferParameteriv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, GLint* @params)
        {
            unsafe { Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params); }
        }
        
        public static 
        void GetBufferParameteriv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetBufferParameteriv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetBufferParameteriv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetBufferPointerv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, void* @params)
        {
            unsafe { Delegates.glGetBufferPointerv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (void*)@params); }
        }
        
        public static 
        void GetBufferPointerv(GL.Enums.VERSION_1_5 target, GL.Enums.VERSION_1_5 pname, object @params)
        {
            System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetBufferPointerv((GL.Enums.VERSION_1_5)target, (GL.Enums.VERSION_1_5)pname, (void*)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }
        }
        
        public static 
        void BlendEquationSeparate(GL.Enums.BlendEquationModeEXT modeRGB, GL.Enums.BlendEquationModeEXT modeAlpha)
        {
            Delegates.glBlendEquationSeparate((GL.Enums.BlendEquationModeEXT)modeRGB, (GL.Enums.BlendEquationModeEXT)modeAlpha);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void DrawBuffers(GLsizei n, GL.Enums.VERSION_2_0* bufs)
        {
            unsafe { Delegates.glDrawBuffers((GLsizei)n, (GL.Enums.VERSION_2_0*)bufs); }
        }
        
        public static 
        void DrawBuffers(GLsizei n, GL.Enums.VERSION_2_0[] bufs)
        {
            unsafe
            {
                fixed (GL.Enums.VERSION_2_0* bufs_ptr = bufs)
                {
                    Delegates.glDrawBuffers((GLsizei)n, (GL.Enums.VERSION_2_0*)bufs_ptr);
                }
            }
        }
        
        public static 
        void DrawBuffers(GLsizei n, ref GL.Enums.VERSION_2_0 bufs)
        {
            unsafe
            {
                fixed (GL.Enums.VERSION_2_0* bufs_ptr = &bufs)
                {
                    Delegates.glDrawBuffers((GLsizei)n, (GL.Enums.VERSION_2_0*)bufs_ptr);
                }
            }
        }
        
        public static 
        void StencilOpSeparate(GL.Enums.VERSION_2_0 face, GL.Enums.StencilOp sfail, GL.Enums.StencilOp dpfail, GL.Enums.StencilOp dppass)
        {
            Delegates.glStencilOpSeparate((GL.Enums.VERSION_2_0)face, (GL.Enums.StencilOp)sfail, (GL.Enums.StencilOp)dpfail, (GL.Enums.StencilOp)dppass);
        }
        
        public static 
        void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, GLint @ref, Int32 mask)
        {
            Delegates.glStencilFuncSeparate((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (GLint)@ref, (GLuint)mask);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, GLint @ref, GLuint mask)
        {
            Delegates.glStencilFuncSeparate((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (GLint)@ref, (GLuint)mask);
        }
        
        public static 
        void StencilMaskSeparate(GL.Enums.VERSION_2_0 face, Int32 mask)
        {
            Delegates.glStencilMaskSeparate((GL.Enums.VERSION_2_0)face, (GLuint)mask);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void StencilMaskSeparate(GL.Enums.VERSION_2_0 face, GLuint mask)
        {
            Delegates.glStencilMaskSeparate((GL.Enums.VERSION_2_0)face, (GLuint)mask);
        }
        
        public static 
        void AttachShader(Int32 program, Int32 shader)
        {
            Delegates.glAttachShader((GLuint)program, (GLuint)shader);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void AttachShader(GLuint program, GLuint shader)
        {
            Delegates.glAttachShader((GLuint)program, (GLuint)shader);
        }
        
        public static 
        void BindAttribLocation(Int32 program, Int32 index, System.String name)
        {
            Delegates.glBindAttribLocation((GLuint)program, (GLuint)index, (System.String)name);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void BindAttribLocation(GLuint program, GLuint index, System.String name)
        {
            Delegates.glBindAttribLocation((GLuint)program, (GLuint)index, (System.String)name);
        }
        
        public static 
        void CompileShader(Int32 shader)
        {
            Delegates.glCompileShader((GLuint)shader);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void CompileShader(GLuint shader)
        {
            Delegates.glCompileShader((GLuint)shader);
        }
        
        public static 
        Int32 CreateProgram()
        {
            return Delegates.glCreateProgram();
        }
        
        public static 
        Int32 CreateShader(GL.Enums.VERSION_2_0 type)
        {
            return Delegates.glCreateShader((GL.Enums.VERSION_2_0)type);
        }
        
        public static 
        void DeleteProgram(Int32 program)
        {
            Delegates.glDeleteProgram((GLuint)program);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteProgram(GLuint program)
        {
            Delegates.glDeleteProgram((GLuint)program);
        }
        
        public static 
        void DeleteShader(Int32 shader)
        {
            Delegates.glDeleteShader((GLuint)shader);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DeleteShader(GLuint shader)
        {
            Delegates.glDeleteShader((GLuint)shader);
        }
        
        public static 
        void DetachShader(Int32 program, Int32 shader)
        {
            Delegates.glDetachShader((GLuint)program, (GLuint)shader);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DetachShader(GLuint program, GLuint shader)
        {
            Delegates.glDetachShader((GLuint)program, (GLuint)shader);
        }
        
        public static 
        void DisableVertexAttribArray(Int32 index)
        {
            Delegates.glDisableVertexAttribArray((GLuint)index);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void DisableVertexAttribArray(GLuint index)
        {
            Delegates.glDisableVertexAttribArray((GLuint)index);
        }
        
        public static 
        void EnableVertexAttribArray(Int32 index)
        {
            Delegates.glEnableVertexAttribArray((GLuint)index);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void EnableVertexAttribArray(GLuint index)
        {
            Delegates.glEnableVertexAttribArray((GLuint)index);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            unsafe { Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        public static 
        void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }
        
        public static 
        void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        public static 
        void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }
        
        public static 
        void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        public static 
        void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }
        
        public static 
        void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
        }
        
        public static 
        void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }
        
        public static 
        void GetActiveAttrib(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            unsafe { Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei*);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                }
        }
        
        public static 
        void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }
        
        public static 
        void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
        }
        
        public static 
        void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }
        
        public static 
        void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint* size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint*);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
        }
        
        public static 
        void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }
        
        public static 
        void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0* type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0*);
            name = default(System.Text.StringBuilder);
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
        }
        
        public static 
        void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, GL.Enums.VERSION_2_0[] type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }
        
        public static 
        void GetActiveUniform(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, out GL.Enums.VERSION_2_0 type, System.Text.StringBuilder name)
        {
            length = default(GLsizei);
            size = default(GLint);
            type = default(GL.Enums.VERSION_2_0);
            name = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                fixed (GLint* size_ptr = &size)
                fixed (GL.Enums.VERSION_2_0* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.VERSION_2_0*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei* count, Int32* obj)
        {
            count = default(GLsizei*);
            obj = default(Int32*);
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj)
        {
            unsafe { Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei* count, Int32[] obj)
        {
            count = default(GLsizei*);
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint[] obj)
        {
            count = default(GLsizei*);
                fixed (GLuint* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj_ptr);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei* count, out Int32 obj)
        {
            count = default(GLsizei*);
            obj = default(Int32);
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj_ptr);
                    obj = *obj_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, out GLuint obj)
        {
            count = default(GLsizei*);
            obj = default(GLuint);
                fixed (GLuint* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count, (GLuint*)obj_ptr);
                    obj = *obj_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei[] count, Int32* obj)
        {
            obj = default(Int32*);
                fixed (GLsizei* count_ptr = count)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, GLuint* obj)
        {
            obj = default(GLuint*);
                fixed (GLsizei* count_ptr = count)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj);
                }
        }
        
        public static 
        void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei[] count, Int32[] obj)
        {
            unsafe
            {
                fixed (GLsizei* count_ptr = count)
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, GLuint[] obj)
        {
            unsafe
            {
                fixed (GLsizei* count_ptr = count)
                fixed (GLuint* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
                }
            }
        }
        
        public static 
        void GetAttachedShaders(Int32 program, GLsizei maxCount, GLsizei[] count, out Int32 obj)
        {
            obj = default(Int32);
            unsafe
            {
                fixed (GLsizei* count_ptr = count)
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, out GLuint obj)
        {
            obj = default(GLuint);
            unsafe
            {
                fixed (GLsizei* count_ptr = count)
                fixed (GLuint* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(Int32 program, GLsizei maxCount, out GLsizei count, Int32* obj)
        {
            count = default(GLsizei);
            obj = default(Int32*);
                fixed (GLsizei* count_ptr = &count)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj);
                    count = *count_ptr;
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, GLuint* obj)
        {
            count = default(GLsizei);
            obj = default(GLuint*);
                fixed (GLsizei* count_ptr = &count)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj);
                    count = *count_ptr;
                }
        }
        
        public static 
        void GetAttachedShaders(Int32 program, GLsizei maxCount, out GLsizei count, Int32[] obj)
        {
            count = default(GLsizei);
            unsafe
            {
                fixed (GLsizei* count_ptr = &count)
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
                    count = *count_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, GLuint[] obj)
        {
            count = default(GLsizei);
            unsafe
            {
                fixed (GLsizei* count_ptr = &count)
                fixed (GLuint* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
                    count = *count_ptr;
                }
            }
        }
        
        public static 
        void GetAttachedShaders(Int32 program, GLsizei maxCount, out GLsizei count, out Int32 obj)
        {
            count = default(GLsizei);
            obj = default(Int32);
            unsafe
            {
                fixed (GLsizei* count_ptr = &count)
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
                    count = *count_ptr;
                    obj = *obj_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, out GLuint obj)
        {
            count = default(GLsizei);
            obj = default(GLuint);
            unsafe
            {
                fixed (GLsizei* count_ptr = &count)
                fixed (GLuint* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((GLuint)program, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLuint*)obj_ptr);
                    count = *count_ptr;
                    obj = *obj_ptr;
                }
            }
        }
        
        public static 
        GLint GetAttribLocation(Int32 program, System.String name)
        {
            return Delegates.glGetAttribLocation((GLuint)program, (System.String)name);
        }
        
        [System.CLSCompliant(false)]
        public static 
        GLint GetAttribLocation(GLuint program, System.String name)
        {
            return Delegates.glGetAttribLocation((GLuint)program, (System.String)name);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetProgramiv(Int32 program, GL.Enums.VERSION_2_0 pname, GLint* @params)
        {
            @params = default(GLint*);
                {
                    Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetProgramiv(GLuint program, GL.Enums.VERSION_2_0 pname, GLint* @params)
        {
            unsafe { Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params); }
        }
        
        public static 
        void GetProgramiv(Int32 program, GL.Enums.VERSION_2_0 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetProgramiv(GLuint program, GL.Enums.VERSION_2_0 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetProgramiv(Int32 program, GL.Enums.VERSION_2_0 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetProgramiv(GLuint program, GL.Enums.VERSION_2_0 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetProgramiv((GLuint)program, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetProgramInfoLog(Int32 program, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder infoLog)
        {
            length = default(GLsizei*);
            infoLog = default(System.Text.StringBuilder);
                {
                    Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder)infoLog);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder infoLog)
        {
            unsafe { Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder)infoLog); }
        }
        
        public static 
        void GetProgramInfoLog(Int32 program, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder infoLog)
        {
            infoLog = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder infoLog)
        {
            infoLog = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }
        
        public static 
        void GetProgramInfoLog(Int32 program, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder infoLog)
        {
            length = default(GLsizei);
            infoLog = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetProgramInfoLog(GLuint program, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder infoLog)
        {
            length = default(GLsizei);
            infoLog = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetProgramInfoLog((GLuint)program, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderiv(Int32 shader, GL.Enums.VERSION_2_0 pname, GLint* @params)
        {
            @params = default(GLint*);
                {
                    Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderiv(GLuint shader, GL.Enums.VERSION_2_0 pname, GLint* @params)
        {
            unsafe { Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params); }
        }
        
        public static 
        void GetShaderiv(Int32 shader, GL.Enums.VERSION_2_0 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetShaderiv(GLuint shader, GL.Enums.VERSION_2_0 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetShaderiv(Int32 shader, GL.Enums.VERSION_2_0 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetShaderiv(GLuint shader, GL.Enums.VERSION_2_0 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetShaderiv((GLuint)shader, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderInfoLog(Int32 shader, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder infoLog)
        {
            length = default(GLsizei*);
            infoLog = default(System.Text.StringBuilder);
                {
                    Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder)infoLog);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder infoLog)
        {
            unsafe { Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder)infoLog); }
        }
        
        public static 
        void GetShaderInfoLog(Int32 shader, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder infoLog)
        {
            infoLog = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder infoLog)
        {
            infoLog = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }
        
        public static 
        void GetShaderInfoLog(Int32 shader, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder infoLog)
        {
            length = default(GLsizei);
            infoLog = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetShaderInfoLog(GLuint shader, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder infoLog)
        {
            length = default(GLsizei);
            infoLog = default(System.Text.StringBuilder);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetShaderInfoLog((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderSource(Int32 shader, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder[] source)
        {
            length = default(GLsizei*);
            source = default(System.Text.StringBuilder[]);
                {
                    Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder[])source);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei* length, System.Text.StringBuilder[] source)
        {
            unsafe { Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length, (System.Text.StringBuilder[])source); }
        }
        
        public static 
        void GetShaderSource(Int32 shader, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder[] source)
        {
            source = default(System.Text.StringBuilder[]);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei[] length, System.Text.StringBuilder[] source)
        {
            source = default(System.Text.StringBuilder[]);
            unsafe
            {
                fixed (GLsizei* length_ptr = length)
                {
                    Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
                }
            }
        }
        
        public static 
        void GetShaderSource(Int32 shader, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder[] source)
        {
            length = default(GLsizei);
            source = default(System.Text.StringBuilder[]);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
                    length = *length_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetShaderSource(GLuint shader, GLsizei bufSize, out GLsizei length, System.Text.StringBuilder[] source)
        {
            length = default(GLsizei);
            source = default(System.Text.StringBuilder[]);
            unsafe
            {
                fixed (GLsizei* length_ptr = &length)
                {
                    Delegates.glGetShaderSource((GLuint)shader, (GLsizei)bufSize, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
                    length = *length_ptr;
                }
            }
        }
        
        public static 
        GLint GetUniformLocation(Int32 program, System.String name)
        {
            return Delegates.glGetUniformLocation((GLuint)program, (System.String)name);
        }
        
        [System.CLSCompliant(false)]
        public static 
        GLint GetUniformLocation(GLuint program, System.String name)
        {
            return Delegates.glGetUniformLocation((GLuint)program, (System.String)name);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetUniformfv(Int32 program, GLint location, GLfloat* @params)
        {
            @params = default(GLfloat*);
                {
                    Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetUniformfv(GLuint program, GLint location, GLfloat* @params)
        {
            unsafe { Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params); }
        }
        
        public static 
        void GetUniformfv(Int32 program, GLint location, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetUniformfv(GLuint program, GLint location, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetUniformfv(Int32 program, GLint location, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetUniformfv(GLuint program, GLint location, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetUniformfv((GLuint)program, (GLint)location, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetUniformiv(Int32 program, GLint location, GLint* @params)
        {
            @params = default(GLint*);
                {
                    Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetUniformiv(GLuint program, GLint location, GLint* @params)
        {
            unsafe { Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params); }
        }
        
        public static 
        void GetUniformiv(Int32 program, GLint location, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetUniformiv(GLuint program, GLint location, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetUniformiv(Int32 program, GLint location, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetUniformiv(GLuint program, GLint location, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetUniformiv((GLuint)program, (GLint)location, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttribdv(Int32 index, GL.Enums.VERSION_2_0 pname, GLdouble* @params)
        {
            @params = default(GLdouble*);
                {
                    Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttribdv(GLuint index, GL.Enums.VERSION_2_0 pname, GLdouble* @params)
        {
            unsafe { Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params); }
        }
        
        public static 
        void GetVertexAttribdv(Int32 index, GL.Enums.VERSION_2_0 pname, GLdouble[] @params)
        {
            unsafe
            {
                fixed (GLdouble* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribdv(GLuint index, GL.Enums.VERSION_2_0 pname, GLdouble[] @params)
        {
            unsafe
            {
                fixed (GLdouble* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetVertexAttribdv(Int32 index, GL.Enums.VERSION_2_0 pname, out GLdouble @params)
        {
            @params = default(GLdouble);
            unsafe
            {
                fixed (GLdouble* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribdv(GLuint index, GL.Enums.VERSION_2_0 pname, out GLdouble @params)
        {
            @params = default(GLdouble);
            unsafe
            {
                fixed (GLdouble* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLdouble*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttribfv(Int32 index, GL.Enums.VERSION_2_0 pname, GLfloat* @params)
        {
            @params = default(GLfloat*);
                {
                    Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttribfv(GLuint index, GL.Enums.VERSION_2_0 pname, GLfloat* @params)
        {
            unsafe { Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params); }
        }
        
        public static 
        void GetVertexAttribfv(Int32 index, GL.Enums.VERSION_2_0 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribfv(GLuint index, GL.Enums.VERSION_2_0 pname, GLfloat[] @params)
        {
            unsafe
            {
                fixed (GLfloat* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetVertexAttribfv(Int32 index, GL.Enums.VERSION_2_0 pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribfv(GLuint index, GL.Enums.VERSION_2_0 pname, out GLfloat @params)
        {
            @params = default(GLfloat);
            unsafe
            {
                fixed (GLfloat* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLfloat*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttribiv(Int32 index, GL.Enums.VERSION_2_0 pname, GLint* @params)
        {
            @params = default(GLint*);
                {
                    Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttribiv(GLuint index, GL.Enums.VERSION_2_0 pname, GLint* @params)
        {
            unsafe { Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params); }
        }
        
        public static 
        void GetVertexAttribiv(Int32 index, GL.Enums.VERSION_2_0 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribiv(GLuint index, GL.Enums.VERSION_2_0 pname, GLint[] @params)
        {
            unsafe
            {
                fixed (GLint* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                }
            }
        }
        
        public static 
        void GetVertexAttribiv(Int32 index, GL.Enums.VERSION_2_0 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribiv(GLuint index, GL.Enums.VERSION_2_0 pname, out GLint @params)
        {
            @params = default(GLint);
            unsafe
            {
                fixed (GLint* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribiv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (GLint*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttribPointerv(Int32 index, GL.Enums.VERSION_2_0 pname, void* pointer)
        {
            pointer = default(void*);
                {
                    Delegates.glGetVertexAttribPointerv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttribPointerv(GLuint index, GL.Enums.VERSION_2_0 pname, void* pointer)
        {
            unsafe { Delegates.glGetVertexAttribPointerv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer); }
        }
        
        public static 
        void GetVertexAttribPointerv(Int32 index, GL.Enums.VERSION_2_0 pname, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetVertexAttribPointerv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribPointerv(GLuint index, GL.Enums.VERSION_2_0 pname, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glGetVertexAttribPointerv((GLuint)index, (GL.Enums.VERSION_2_0)pname, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        public static 
        GLboolean IsProgram(Int32 program)
        {
            return Delegates.glIsProgram((GLuint)program);
        }
        
        [System.CLSCompliant(false)]
        public static 
        GLboolean IsProgram(GLuint program)
        {
            return Delegates.glIsProgram((GLuint)program);
        }
        
        public static 
        GLboolean IsShader(Int32 shader)
        {
            return Delegates.glIsShader((GLuint)shader);
        }
        
        [System.CLSCompliant(false)]
        public static 
        GLboolean IsShader(GLuint shader)
        {
            return Delegates.glIsShader((GLuint)shader);
        }
        
        public static 
        void LinkProgram(Int32 program)
        {
            Delegates.glLinkProgram((GLuint)program);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void LinkProgram(GLuint program)
        {
            Delegates.glLinkProgram((GLuint)program);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ShaderSource(Int32 shader, GLsizei count, System.String[] @string, GLint* length)
        {
                {
                    Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ShaderSource(GLuint shader, GLsizei count, System.String[] @string, GLint* length)
        {
            unsafe { Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length); }
        }
        
        public static 
        void ShaderSource(Int32 shader, GLsizei count, System.String[] @string, GLint[] length)
        {
            unsafe
            {
                fixed (GLint* length_ptr = length)
                {
                    Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void ShaderSource(GLuint shader, GLsizei count, System.String[] @string, GLint[] length)
        {
            unsafe
            {
                fixed (GLint* length_ptr = length)
                {
                    Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
                }
            }
        }
        
        public static 
        void ShaderSource(Int32 shader, GLsizei count, System.String[] @string, ref GLint length)
        {
            unsafe
            {
                fixed (GLint* length_ptr = &length)
                {
                    Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void ShaderSource(GLuint shader, GLsizei count, System.String[] @string, ref GLint length)
        {
            unsafe
            {
                fixed (GLint* length_ptr = &length)
                {
                    Delegates.glShaderSource((GLuint)shader, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
                }
            }
        }
        
        public static 
        void UseProgram(Int32 program)
        {
            Delegates.glUseProgram((GLuint)program);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void UseProgram(GLuint program)
        {
            Delegates.glUseProgram((GLuint)program);
        }
        
        public static 
        void Uniform1f(GLint location, GLfloat v0)
        {
            Delegates.glUniform1f((GLint)location, (GLfloat)v0);
        }
        
        public static 
        void Uniform2f(GLint location, GLfloat v0, GLfloat v1)
        {
            Delegates.glUniform2f((GLint)location, (GLfloat)v0, (GLfloat)v1);
        }
        
        public static 
        void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
        {
            Delegates.glUniform3f((GLint)location, (GLfloat)v0, (GLfloat)v1, (GLfloat)v2);
        }
        
        public static 
        void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
        {
            Delegates.glUniform4f((GLint)location, (GLfloat)v0, (GLfloat)v1, (GLfloat)v2, (GLfloat)v3);
        }
        
        public static 
        void Uniform1i(GLint location, GLint v0)
        {
            Delegates.glUniform1i((GLint)location, (GLint)v0);
        }
        
        public static 
        void Uniform2i(GLint location, GLint v0, GLint v1)
        {
            Delegates.glUniform2i((GLint)location, (GLint)v0, (GLint)v1);
        }
        
        public static 
        void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
        {
            Delegates.glUniform3i((GLint)location, (GLint)v0, (GLint)v1, (GLint)v2);
        }
        
        public static 
        void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
        {
            Delegates.glUniform4i((GLint)location, (GLint)v0, (GLint)v1, (GLint)v2, (GLint)v3);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform1fv(GLint location, GLsizei count, GLfloat* value)
        {
            unsafe { Delegates.glUniform1fv((GLint)location, (GLsizei)count, (GLfloat*)value); }
        }
        
        public static 
        void Uniform1fv(GLint location, GLsizei count, GLfloat[] value)
        {
            unsafe
            {
                fixed (GLfloat* value_ptr = value)
                {
                    Delegates.glUniform1fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                }
            }
        }
        
        public static 
        void Uniform1fv(GLint location, GLsizei count, ref GLfloat value)
        {
            unsafe
            {
                fixed (GLfloat* value_ptr = &value)
                {
                    Delegates.glUniform1fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform2fv(GLint location, GLsizei count, GLfloat* value)
        {
            unsafe { Delegates.glUniform2fv((GLint)location, (GLsizei)count, (GLfloat*)value); }
        }
        
        public static 
        void Uniform2fv(GLint location, GLsizei count, GLfloat[] value)
        {
            unsafe
            {
                fixed (GLfloat* value_ptr = value)
                {
                    Delegates.glUniform2fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                }
            }
        }
        
        public static 
        void Uniform2fv(GLint location, GLsizei count, ref GLfloat value)
        {
            unsafe
            {
                fixed (GLfloat* value_ptr = &value)
                {
                    Delegates.glUniform2fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform3fv(GLint location, GLsizei count, GLfloat* value)
        {
            unsafe { Delegates.glUniform3fv((GLint)location, (GLsizei)count, (GLfloat*)value); }
        }
        
        public static 
        void Uniform3fv(GLint location, GLsizei count, GLfloat[] value)
        {
            unsafe
            {
                fixed (GLfloat* value_ptr = value)
                {
                    Delegates.glUniform3fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                }
            }
        }
        
        public static 
        void Uniform3fv(GLint location, GLsizei count, ref GLfloat value)
        {
            unsafe
            {
                fixed (GLfloat* value_ptr = &value)
                {
                    Delegates.glUniform3fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform4fv(GLint location, GLsizei count, GLfloat* value)
        {
            unsafe { Delegates.glUniform4fv((GLint)location, (GLsizei)count, (GLfloat*)value); }
        }
        
        public static 
        void Uniform4fv(GLint location, GLsizei count, GLfloat[] value)
        {
            unsafe
            {
                fixed (GLfloat* value_ptr = value)
                {
                    Delegates.glUniform4fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                }
            }
        }
        
        public static 
        void Uniform4fv(GLint location, GLsizei count, ref GLfloat value)
        {
            unsafe
            {
                fixed (GLfloat* value_ptr = &value)
                {
                    Delegates.glUniform4fv((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform1iv(GLint location, GLsizei count, GLint* value)
        {
            unsafe { Delegates.glUniform1iv((GLint)location, (GLsizei)count, (GLint*)value); }
        }
        
        public static 
        void Uniform1iv(GLint location, GLsizei count, GLint[] value)
        {
            unsafe
            {
                fixed (GLint* value_ptr = value)
                {
                    Delegates.glUniform1iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                }
            }
        }
        
        public static 
        void Uniform1iv(GLint location, GLsizei count, ref GLint value)
        {
            unsafe
            {
                fixed (GLint* value_ptr = &value)
                {
                    Delegates.glUniform1iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform2iv(GLint location, GLsizei count, GLint* value)
        {
            unsafe { Delegates.glUniform2iv((GLint)location, (GLsizei)count, (GLint*)value); }
        }
        
        public static 
        void Uniform2iv(GLint location, GLsizei count, GLint[] value)
        {
            unsafe
            {
                fixed (GLint* value_ptr = value)
                {
                    Delegates.glUniform2iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                }
            }
        }
        
        public static 
        void Uniform2iv(GLint location, GLsizei count, ref GLint value)
        {
            unsafe
            {
                fixed (GLint* value_ptr = &value)
                {
                    Delegates.glUniform2iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform3iv(GLint location, GLsizei count, GLint* value)
        {
            unsafe { Delegates.glUniform3iv((GLint)location, (GLsizei)count, (GLint*)value); }
        }
        
        public static 
        void Uniform3iv(GLint location, GLsizei count, GLint[] value)
        {
            unsafe
            {
                fixed (GLint* value_ptr = value)
                {
                    Delegates.glUniform3iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                }
            }
        }
        
        public static 
        void Uniform3iv(GLint location, GLsizei count, ref GLint value)
        {
            unsafe
            {
                fixed (GLint* value_ptr = &value)
                {
                    Delegates.glUniform3iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform4iv(GLint location, GLsizei count, GLint* value)
        {
            unsafe { Delegates.glUniform4iv((GLint)location, (GLsizei)count, (GLint*)value); }
        }
        
        public static 
        void Uniform4iv(GLint location, GLsizei count, GLint[] value)
        {
            unsafe
            {
                fixed (GLint* value_ptr = value)
                {
                    Delegates.glUniform4iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                }
            }
        }
        
        public static 
        void Uniform4iv(GLint location, GLsizei count, ref GLint value)
        {
            unsafe
            {
                fixed (GLint* value_ptr = &value)
                {
                    Delegates.glUniform4iv((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix2fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix2fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix3fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix3fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix4fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix4fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        public static 
        void ValidateProgram(Int32 program)
        {
            Delegates.glValidateProgram((GLuint)program);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void ValidateProgram(GLuint program)
        {
            Delegates.glValidateProgram((GLuint)program);
        }
        
        public static 
        void VertexAttrib1d(Int32 index, GLdouble x)
        {
            Delegates.glVertexAttrib1d((GLuint)index, (GLdouble)x);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1d(GLuint index, GLdouble x)
        {
            Delegates.glVertexAttrib1d((GLuint)index, (GLdouble)x);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1dv(Int32 index, GLdouble* v)
        {
                {
                    Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1dv(GLuint index, GLdouble* v)
        {
            unsafe { Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v); }
        }
        
        public static 
        void VertexAttrib1dv(Int32 index, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1dv(GLuint index, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib1dv(Int32 index, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1dv(GLuint index, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib1f(Int32 index, GLfloat x)
        {
            Delegates.glVertexAttrib1f((GLuint)index, (GLfloat)x);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1f(GLuint index, GLfloat x)
        {
            Delegates.glVertexAttrib1f((GLuint)index, (GLfloat)x);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1fv(Int32 index, GLfloat* v)
        {
                {
                    Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1fv(GLuint index, GLfloat* v)
        {
            unsafe { Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v); }
        }
        
        public static 
        void VertexAttrib1fv(Int32 index, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1fv(GLuint index, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib1fv(Int32 index, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1fv(GLuint index, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib1s(Int32 index, GLshort x)
        {
            Delegates.glVertexAttrib1s((GLuint)index, (GLshort)x);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1s(GLuint index, GLshort x)
        {
            Delegates.glVertexAttrib1s((GLuint)index, (GLshort)x);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1sv(Int32 index, GLshort* v)
        {
                {
                    Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1sv(GLuint index, GLshort* v)
        {
            unsafe { Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v); }
        }
        
        public static 
        void VertexAttrib1sv(Int32 index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1sv(GLuint index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib1sv(Int32 index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1sv(GLuint index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib2d(Int32 index, GLdouble x, GLdouble y)
        {
            Delegates.glVertexAttrib2d((GLuint)index, (GLdouble)x, (GLdouble)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
        {
            Delegates.glVertexAttrib2d((GLuint)index, (GLdouble)x, (GLdouble)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2dv(Int32 index, GLdouble* v)
        {
                {
                    Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2dv(GLuint index, GLdouble* v)
        {
            unsafe { Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v); }
        }
        
        public static 
        void VertexAttrib2dv(Int32 index, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2dv(GLuint index, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib2dv(Int32 index, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2dv(GLuint index, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib2f(Int32 index, GLfloat x, GLfloat y)
        {
            Delegates.glVertexAttrib2f((GLuint)index, (GLfloat)x, (GLfloat)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
        {
            Delegates.glVertexAttrib2f((GLuint)index, (GLfloat)x, (GLfloat)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2fv(Int32 index, GLfloat* v)
        {
                {
                    Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2fv(GLuint index, GLfloat* v)
        {
            unsafe { Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v); }
        }
        
        public static 
        void VertexAttrib2fv(Int32 index, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2fv(GLuint index, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib2fv(Int32 index, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2fv(GLuint index, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib2s(Int32 index, GLshort x, GLshort y)
        {
            Delegates.glVertexAttrib2s((GLuint)index, (GLshort)x, (GLshort)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2s(GLuint index, GLshort x, GLshort y)
        {
            Delegates.glVertexAttrib2s((GLuint)index, (GLshort)x, (GLshort)y);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2sv(Int32 index, GLshort* v)
        {
                {
                    Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2sv(GLuint index, GLshort* v)
        {
            unsafe { Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v); }
        }
        
        public static 
        void VertexAttrib2sv(Int32 index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2sv(GLuint index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib2sv(Int32 index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2sv(GLuint index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib3d(Int32 index, GLdouble x, GLdouble y, GLdouble z)
        {
            Delegates.glVertexAttrib3d((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
        {
            Delegates.glVertexAttrib3d((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3dv(Int32 index, GLdouble* v)
        {
                {
                    Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3dv(GLuint index, GLdouble* v)
        {
            unsafe { Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v); }
        }
        
        public static 
        void VertexAttrib3dv(Int32 index, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3dv(GLuint index, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib3dv(Int32 index, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3dv(GLuint index, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib3f(Int32 index, GLfloat x, GLfloat y, GLfloat z)
        {
            Delegates.glVertexAttrib3f((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
        {
            Delegates.glVertexAttrib3f((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3fv(Int32 index, GLfloat* v)
        {
                {
                    Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3fv(GLuint index, GLfloat* v)
        {
            unsafe { Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v); }
        }
        
        public static 
        void VertexAttrib3fv(Int32 index, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3fv(GLuint index, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib3fv(Int32 index, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3fv(GLuint index, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib3s(Int32 index, GLshort x, GLshort y, GLshort z)
        {
            Delegates.glVertexAttrib3s((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
        {
            Delegates.glVertexAttrib3s((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3sv(Int32 index, GLshort* v)
        {
                {
                    Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3sv(GLuint index, GLshort* v)
        {
            unsafe { Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v); }
        }
        
        public static 
        void VertexAttrib3sv(Int32 index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3sv(GLuint index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib3sv(Int32 index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3sv(GLuint index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nbv(Int32 index, Byte* v)
        {
                {
                    Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nbv(GLuint index, GLbyte* v)
        {
            unsafe { Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v); }
        }
        
        public static 
        void VertexAttrib4Nbv(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nbv(GLuint index, GLbyte[] v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4Nbv(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nbv(GLuint index, ref GLbyte v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nbv((GLuint)index, (GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Niv(Int32 index, GLint* v)
        {
                {
                    Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Niv(GLuint index, GLint* v)
        {
            unsafe { Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v); }
        }
        
        public static 
        void VertexAttrib4Niv(Int32 index, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Niv(GLuint index, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4Niv(Int32 index, ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Niv(GLuint index, ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Niv((GLuint)index, (GLint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nsv(Int32 index, GLshort* v)
        {
                {
                    Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nsv(GLuint index, GLshort* v)
        {
            unsafe { Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v); }
        }
        
        public static 
        void VertexAttrib4Nsv(Int32 index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nsv(GLuint index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4Nsv(Int32 index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nsv(GLuint index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nsv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4Nub(Int32 index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
        {
            Delegates.glVertexAttrib4Nub((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
        {
            Delegates.glVertexAttrib4Nub((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nubv(Int32 index, GLubyte* v)
        {
                {
                    Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nubv(GLuint index, GLubyte* v)
        {
            unsafe { Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v); }
        }
        
        public static 
        void VertexAttrib4Nubv(Int32 index, GLubyte[] v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nubv(GLuint index, GLubyte[] v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4Nubv(Int32 index, ref GLubyte v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nubv(GLuint index, ref GLubyte v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nubv((GLuint)index, (GLubyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nuiv(Int32 index, Int32* v)
        {
                {
                    Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nuiv(GLuint index, GLuint* v)
        {
            unsafe { Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v); }
        }
        
        public static 
        void VertexAttrib4Nuiv(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nuiv(GLuint index, GLuint[] v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4Nuiv(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nuiv(GLuint index, ref GLuint v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nuiv((GLuint)index, (GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nusv(Int32 index, Int16* v)
        {
                {
                    Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4Nusv(GLuint index, GLushort* v)
        {
            unsafe { Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v); }
        }
        
        public static 
        void VertexAttrib4Nusv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nusv(GLuint index, GLushort[] v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4Nusv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4Nusv(GLuint index, ref GLushort v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nusv((GLuint)index, (GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4bv(Int32 index, Byte* v)
        {
                {
                    Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4bv(GLuint index, GLbyte* v)
        {
            unsafe { Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v); }
        }
        
        public static 
        void VertexAttrib4bv(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4bv(GLuint index, GLbyte[] v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4bv(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4bv(GLuint index, ref GLbyte v)
        {
            unsafe
            {
                fixed (GLbyte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4bv((GLuint)index, (GLbyte*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4d(Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
        {
            Delegates.glVertexAttrib4d((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
        {
            Delegates.glVertexAttrib4d((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4dv(Int32 index, GLdouble* v)
        {
                {
                    Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4dv(GLuint index, GLdouble* v)
        {
            unsafe { Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v); }
        }
        
        public static 
        void VertexAttrib4dv(Int32 index, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4dv(GLuint index, GLdouble[] v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4dv(Int32 index, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4dv(GLuint index, ref GLdouble v)
        {
            unsafe
            {
                fixed (GLdouble* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dv((GLuint)index, (GLdouble*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4f(Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
        {
            Delegates.glVertexAttrib4f((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
        {
            Delegates.glVertexAttrib4f((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4fv(Int32 index, GLfloat* v)
        {
                {
                    Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4fv(GLuint index, GLfloat* v)
        {
            unsafe { Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v); }
        }
        
        public static 
        void VertexAttrib4fv(Int32 index, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4fv(GLuint index, GLfloat[] v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4fv(Int32 index, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4fv(GLuint index, ref GLfloat v)
        {
            unsafe
            {
                fixed (GLfloat* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fv((GLuint)index, (GLfloat*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4iv(Int32 index, GLint* v)
        {
                {
                    Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4iv(GLuint index, GLint* v)
        {
            unsafe { Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v); }
        }
        
        public static 
        void VertexAttrib4iv(Int32 index, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4iv(GLuint index, GLint[] v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = v)
                {
                    Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4iv(Int32 index, ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4iv(GLuint index, ref GLint v)
        {
            unsafe
            {
                fixed (GLint* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4iv((GLuint)index, (GLint*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4s(Int32 index, GLshort x, GLshort y, GLshort z, GLshort w)
        {
            Delegates.glVertexAttrib4s((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
        {
            Delegates.glVertexAttrib4s((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4sv(Int32 index, GLshort* v)
        {
                {
                    Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4sv(GLuint index, GLshort* v)
        {
            unsafe { Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v); }
        }
        
        public static 
        void VertexAttrib4sv(Int32 index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4sv(GLuint index, GLshort[] v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = v)
                {
                    Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4sv(Int32 index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4sv(GLuint index, ref GLshort v)
        {
            unsafe
            {
                fixed (GLshort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4sv((GLuint)index, (GLshort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4ubv(Int32 index, GLubyte* v)
        {
                {
                    Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4ubv(GLuint index, GLubyte* v)
        {
            unsafe { Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v); }
        }
        
        public static 
        void VertexAttrib4ubv(Int32 index, GLubyte[] v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4ubv(GLuint index, GLubyte[] v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4ubv(Int32 index, ref GLubyte v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4ubv(GLuint index, ref GLubyte v)
        {
            unsafe
            {
                fixed (GLubyte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubv((GLuint)index, (GLubyte*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4uiv(Int32 index, Int32* v)
        {
                {
                    Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4uiv(GLuint index, GLuint* v)
        {
            unsafe { Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v); }
        }
        
        public static 
        void VertexAttrib4uiv(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4uiv(GLuint index, GLuint[] v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = v)
                {
                    Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4uiv(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4uiv(GLuint index, ref GLuint v)
        {
            unsafe
            {
                fixed (GLuint* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4uiv((GLuint)index, (GLuint*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4usv(Int32 index, Int16* v)
        {
                {
                    Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4usv(GLuint index, GLushort* v)
        {
            unsafe { Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v); }
        }
        
        public static 
        void VertexAttrib4usv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4usv(GLuint index, GLushort[] v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = v)
                {
                    Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v_ptr);
                }
            }
        }
        
        public static 
        void VertexAttrib4usv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4usv(GLuint index, ref GLushort v)
        {
            unsafe
            {
                fixed (GLushort* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4usv((GLuint)index, (GLushort*)v_ptr);
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttribPointer(Int32 index, GLint size, GL.Enums.VERSION_2_0 type, GL.Enums.Boolean normalized, GLsizei stride, void* pointer)
        {
                {
                    Delegates.glVertexAttribPointer((GLuint)index, (GLint)size, (GL.Enums.VERSION_2_0)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (void*)pointer);
                }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttribPointer(GLuint index, GLint size, GL.Enums.VERSION_2_0 type, GL.Enums.Boolean normalized, GLsizei stride, void* pointer)
        {
            unsafe { Delegates.glVertexAttribPointer((GLuint)index, (GLint)size, (GL.Enums.VERSION_2_0)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (void*)pointer); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix2x3fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix2x3fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix3x2fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix3x2fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix2x4fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix2x4fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix4x2fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix4x2fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix3x4fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix3x4fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix4x3fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
        {
            unsafe { Delegates.glUniformMatrix4x3fv((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexPointervINTEL(GLint size, GL.Enums.VertexPointerType type, void* pointer)
        {
            unsafe { Delegates.glVertexPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
        }
        
        public static 
        void VertexPointervINTEL(GLint size, GL.Enums.VertexPointerType type, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glVertexPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void NormalPointervINTEL(GL.Enums.NormalPointerType type, void* pointer)
        {
            unsafe { Delegates.glNormalPointervINTEL((GL.Enums.NormalPointerType)type, (void*)pointer); }
        }
        
        public static 
        void NormalPointervINTEL(GL.Enums.NormalPointerType type, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glNormalPointervINTEL((GL.Enums.NormalPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void ColorPointervINTEL(GLint size, GL.Enums.VertexPointerType type, void* pointer)
        {
            unsafe { Delegates.glColorPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
        }
        
        public static 
        void ColorPointervINTEL(GLint size, GL.Enums.VertexPointerType type, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glColorPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoordPointervINTEL(GLint size, GL.Enums.VertexPointerType type, void* pointer)
        {
            unsafe { Delegates.glTexCoordPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer); }
        }
        
        public static 
        void TexCoordPointervINTEL(GLint size, GL.Enums.VertexPointerType type, object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            unsafe
            {
                try
                {
                    Delegates.glTexCoordPointervINTEL((GLint)size, (GL.Enums.VertexPointerType)type, (void*)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }
        
        public static 
        void TbufferMask3DFX(Int32 mask)
        {
            Delegates.glTbufferMask3DFX((GLuint)mask);
        }
        
        [System.CLSCompliant(false)]
        public static 
        void TbufferMask3DFX(GLuint mask)
        {
            Delegates.glTbufferMask3DFX((GLuint)mask);
        }
        
        public static class ARB
        {
            public static 
            void ActiveTexture(GL.Enums.ARB_multitexture texture)
            {
                Delegates.glActiveTextureARB((GL.Enums.ARB_multitexture)texture);
            }
            
            public static 
            void ClientActiveTexture(GL.Enums.ARB_multitexture texture)
            {
                Delegates.glClientActiveTextureARB((GL.Enums.ARB_multitexture)texture);
            }
            
            public static 
            void MultiTexCoord1d(GL.Enums.ARB_multitexture target, GLdouble s)
            {
                Delegates.glMultiTexCoord1dARB((GL.Enums.ARB_multitexture)target, (GLdouble)s);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1dv(GL.Enums.ARB_multitexture target, GLdouble* v)
            {
                unsafe { Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v); }
            }
            
            public static 
            void MultiTexCoord1dv(GL.Enums.ARB_multitexture target, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1dv(GL.Enums.ARB_multitexture target, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1f(GL.Enums.ARB_multitexture target, GLfloat s)
            {
                Delegates.glMultiTexCoord1fARB((GL.Enums.ARB_multitexture)target, (GLfloat)s);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1fv(GL.Enums.ARB_multitexture target, GLfloat* v)
            {
                unsafe { Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v); }
            }
            
            public static 
            void MultiTexCoord1fv(GL.Enums.ARB_multitexture target, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1fv(GL.Enums.ARB_multitexture target, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1i(GL.Enums.ARB_multitexture target, GLint s)
            {
                Delegates.glMultiTexCoord1iARB((GL.Enums.ARB_multitexture)target, (GLint)s);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1iv(GL.Enums.ARB_multitexture target, GLint* v)
            {
                unsafe { Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v); }
            }
            
            public static 
            void MultiTexCoord1iv(GL.Enums.ARB_multitexture target, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1iv(GL.Enums.ARB_multitexture target, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1s(GL.Enums.ARB_multitexture target, GLshort s)
            {
                Delegates.glMultiTexCoord1sARB((GL.Enums.ARB_multitexture)target, (GLshort)s);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1sv(GL.Enums.ARB_multitexture target, GLshort* v)
            {
                unsafe { Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v); }
            }
            
            public static 
            void MultiTexCoord1sv(GL.Enums.ARB_multitexture target, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1sv(GL.Enums.ARB_multitexture target, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2d(GL.Enums.ARB_multitexture target, GLdouble s, GLdouble t)
            {
                Delegates.glMultiTexCoord2dARB((GL.Enums.ARB_multitexture)target, (GLdouble)s, (GLdouble)t);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2dv(GL.Enums.ARB_multitexture target, GLdouble* v)
            {
                unsafe { Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v); }
            }
            
            public static 
            void MultiTexCoord2dv(GL.Enums.ARB_multitexture target, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2dv(GL.Enums.ARB_multitexture target, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2f(GL.Enums.ARB_multitexture target, GLfloat s, GLfloat t)
            {
                Delegates.glMultiTexCoord2fARB((GL.Enums.ARB_multitexture)target, (GLfloat)s, (GLfloat)t);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2fv(GL.Enums.ARB_multitexture target, GLfloat* v)
            {
                unsafe { Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v); }
            }
            
            public static 
            void MultiTexCoord2fv(GL.Enums.ARB_multitexture target, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2fv(GL.Enums.ARB_multitexture target, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2i(GL.Enums.ARB_multitexture target, GLint s, GLint t)
            {
                Delegates.glMultiTexCoord2iARB((GL.Enums.ARB_multitexture)target, (GLint)s, (GLint)t);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2iv(GL.Enums.ARB_multitexture target, GLint* v)
            {
                unsafe { Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v); }
            }
            
            public static 
            void MultiTexCoord2iv(GL.Enums.ARB_multitexture target, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2iv(GL.Enums.ARB_multitexture target, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2s(GL.Enums.ARB_multitexture target, GLshort s, GLshort t)
            {
                Delegates.glMultiTexCoord2sARB((GL.Enums.ARB_multitexture)target, (GLshort)s, (GLshort)t);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2sv(GL.Enums.ARB_multitexture target, GLshort* v)
            {
                unsafe { Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v); }
            }
            
            public static 
            void MultiTexCoord2sv(GL.Enums.ARB_multitexture target, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2sv(GL.Enums.ARB_multitexture target, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3d(GL.Enums.ARB_multitexture target, GLdouble s, GLdouble t, GLdouble r)
            {
                Delegates.glMultiTexCoord3dARB((GL.Enums.ARB_multitexture)target, (GLdouble)s, (GLdouble)t, (GLdouble)r);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3dv(GL.Enums.ARB_multitexture target, GLdouble* v)
            {
                unsafe { Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v); }
            }
            
            public static 
            void MultiTexCoord3dv(GL.Enums.ARB_multitexture target, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3dv(GL.Enums.ARB_multitexture target, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3f(GL.Enums.ARB_multitexture target, GLfloat s, GLfloat t, GLfloat r)
            {
                Delegates.glMultiTexCoord3fARB((GL.Enums.ARB_multitexture)target, (GLfloat)s, (GLfloat)t, (GLfloat)r);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3fv(GL.Enums.ARB_multitexture target, GLfloat* v)
            {
                unsafe { Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v); }
            }
            
            public static 
            void MultiTexCoord3fv(GL.Enums.ARB_multitexture target, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3fv(GL.Enums.ARB_multitexture target, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3i(GL.Enums.ARB_multitexture target, GLint s, GLint t, GLint r)
            {
                Delegates.glMultiTexCoord3iARB((GL.Enums.ARB_multitexture)target, (GLint)s, (GLint)t, (GLint)r);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3iv(GL.Enums.ARB_multitexture target, GLint* v)
            {
                unsafe { Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v); }
            }
            
            public static 
            void MultiTexCoord3iv(GL.Enums.ARB_multitexture target, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3iv(GL.Enums.ARB_multitexture target, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3s(GL.Enums.ARB_multitexture target, GLshort s, GLshort t, GLshort r)
            {
                Delegates.glMultiTexCoord3sARB((GL.Enums.ARB_multitexture)target, (GLshort)s, (GLshort)t, (GLshort)r);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3sv(GL.Enums.ARB_multitexture target, GLshort* v)
            {
                unsafe { Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v); }
            }
            
            public static 
            void MultiTexCoord3sv(GL.Enums.ARB_multitexture target, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3sv(GL.Enums.ARB_multitexture target, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4d(GL.Enums.ARB_multitexture target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
            {
                Delegates.glMultiTexCoord4dARB((GL.Enums.ARB_multitexture)target, (GLdouble)s, (GLdouble)t, (GLdouble)r, (GLdouble)q);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4dv(GL.Enums.ARB_multitexture target, GLdouble* v)
            {
                unsafe { Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v); }
            }
            
            public static 
            void MultiTexCoord4dv(GL.Enums.ARB_multitexture target, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4dv(GL.Enums.ARB_multitexture target, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4dvARB((GL.Enums.ARB_multitexture)target, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4f(GL.Enums.ARB_multitexture target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
            {
                Delegates.glMultiTexCoord4fARB((GL.Enums.ARB_multitexture)target, (GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)q);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4fv(GL.Enums.ARB_multitexture target, GLfloat* v)
            {
                unsafe { Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v); }
            }
            
            public static 
            void MultiTexCoord4fv(GL.Enums.ARB_multitexture target, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4fv(GL.Enums.ARB_multitexture target, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4fvARB((GL.Enums.ARB_multitexture)target, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4i(GL.Enums.ARB_multitexture target, GLint s, GLint t, GLint r, GLint q)
            {
                Delegates.glMultiTexCoord4iARB((GL.Enums.ARB_multitexture)target, (GLint)s, (GLint)t, (GLint)r, (GLint)q);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4iv(GL.Enums.ARB_multitexture target, GLint* v)
            {
                unsafe { Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v); }
            }
            
            public static 
            void MultiTexCoord4iv(GL.Enums.ARB_multitexture target, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4iv(GL.Enums.ARB_multitexture target, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4ivARB((GL.Enums.ARB_multitexture)target, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4s(GL.Enums.ARB_multitexture target, GLshort s, GLshort t, GLshort r, GLshort q)
            {
                Delegates.glMultiTexCoord4sARB((GL.Enums.ARB_multitexture)target, (GLshort)s, (GLshort)t, (GLshort)r, (GLshort)q);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4sv(GL.Enums.ARB_multitexture target, GLshort* v)
            {
                unsafe { Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v); }
            }
            
            public static 
            void MultiTexCoord4sv(GL.Enums.ARB_multitexture target, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4sv(GL.Enums.ARB_multitexture target, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4svARB((GL.Enums.ARB_multitexture)target, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void LoadTransposeMatrixf(GLfloat* m)
            {
                unsafe { Delegates.glLoadTransposeMatrixfARB((GLfloat*)m); }
            }
            
            public static 
            void LoadTransposeMatrixf(GLfloat[] m)
            {
                unsafe
                {
                    fixed (GLfloat* m_ptr = m)
                    {
                        Delegates.glLoadTransposeMatrixfARB((GLfloat*)m_ptr);
                    }
                }
            }
            
            public static 
            void LoadTransposeMatrixf(ref GLfloat m)
            {
                unsafe
                {
                    fixed (GLfloat* m_ptr = &m)
                    {
                        Delegates.glLoadTransposeMatrixfARB((GLfloat*)m_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void LoadTransposeMatrixd(GLdouble* m)
            {
                unsafe { Delegates.glLoadTransposeMatrixdARB((GLdouble*)m); }
            }
            
            public static 
            void LoadTransposeMatrixd(GLdouble[] m)
            {
                unsafe
                {
                    fixed (GLdouble* m_ptr = m)
                    {
                        Delegates.glLoadTransposeMatrixdARB((GLdouble*)m_ptr);
                    }
                }
            }
            
            public static 
            void LoadTransposeMatrixd(ref GLdouble m)
            {
                unsafe
                {
                    fixed (GLdouble* m_ptr = &m)
                    {
                        Delegates.glLoadTransposeMatrixdARB((GLdouble*)m_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultTransposeMatrixf(GLfloat* m)
            {
                unsafe { Delegates.glMultTransposeMatrixfARB((GLfloat*)m); }
            }
            
            public static 
            void MultTransposeMatrixf(GLfloat[] m)
            {
                unsafe
                {
                    fixed (GLfloat* m_ptr = m)
                    {
                        Delegates.glMultTransposeMatrixfARB((GLfloat*)m_ptr);
                    }
                }
            }
            
            public static 
            void MultTransposeMatrixf(ref GLfloat m)
            {
                unsafe
                {
                    fixed (GLfloat* m_ptr = &m)
                    {
                        Delegates.glMultTransposeMatrixfARB((GLfloat*)m_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultTransposeMatrixd(GLdouble* m)
            {
                unsafe { Delegates.glMultTransposeMatrixdARB((GLdouble*)m); }
            }
            
            public static 
            void MultTransposeMatrixd(GLdouble[] m)
            {
                unsafe
                {
                    fixed (GLdouble* m_ptr = m)
                    {
                        Delegates.glMultTransposeMatrixdARB((GLdouble*)m_ptr);
                    }
                }
            }
            
            public static 
            void MultTransposeMatrixd(ref GLdouble m)
            {
                unsafe
                {
                    fixed (GLdouble* m_ptr = &m)
                    {
                        Delegates.glMultTransposeMatrixdARB((GLdouble*)m_ptr);
                    }
                }
            }
            
            public static 
            void SampleCoverage(GLclampf value, GL.Enums.Boolean invert)
            {
                 Delegates.glSampleCoverageARB((GLclampf)value, (GL.Enums.Boolean)invert); 
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CompressedTexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, void* data)
            {
                unsafe { Delegates.glCompressedTexImage3DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GLsizei)imageSize, (void*)data); }
            }
            
            public static 
            void CompressedTexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glCompressedTexImage3DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CompressedTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, void* data)
            {
                unsafe { Delegates.glCompressedTexImage2DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLsizei)imageSize, (void*)data); }
            }
            
            public static 
            void CompressedTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glCompressedTexImage2DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CompressedTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, void* data)
            {
                unsafe { Delegates.glCompressedTexImage1DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLint)border, (GLsizei)imageSize, (void*)data); }
            }
            
            public static 
            void CompressedTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glCompressedTexImage1DARB((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLint)border, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CompressedTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
            {
                unsafe { Delegates.glCompressedTexSubImage3DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
            }
            
            public static 
            void CompressedTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glCompressedTexSubImage3DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CompressedTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
            {
                unsafe { Delegates.glCompressedTexSubImage2DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
            }
            
            public static 
            void CompressedTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glCompressedTexSubImage2DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CompressedTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GLsizei imageSize, void* data)
            {
                unsafe { Delegates.glCompressedTexSubImage1DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data); }
            }
            
            public static 
            void CompressedTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GLsizei imageSize, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glCompressedTexSubImage1DARB((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GLsizei)imageSize, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCompressedTexImage(GL.Enums.TextureTarget target, GLint level, void* img)
            {
                unsafe { Delegates.glGetCompressedTexImageARB((GL.Enums.TextureTarget)target, (GLint)level, (void*)img); }
            }
            
            public static 
            void GetCompressedTexImage(GL.Enums.TextureTarget target, GLint level, object img)
            {
                System.Runtime.InteropServices.GCHandle img_ptr = System.Runtime.InteropServices.GCHandle.Alloc(img, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetCompressedTexImageARB((GL.Enums.TextureTarget)target, (GLint)level, (void*)img_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        img_ptr.Free();
                    }
                }
            }
            
            public static 
            void PointParameterf(GL.Enums.ARB_point_parameters pname, GLfloat param)
            {
                Delegates.glPointParameterfARB((GL.Enums.ARB_point_parameters)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PointParameterfv(GL.Enums.ARB_point_parameters pname, GLfloat* @params)
            {
                unsafe { Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (GLfloat*)@params); }
            }
            
            public static 
            void PointParameterfv(GL.Enums.ARB_point_parameters pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PointParameterfv(GL.Enums.ARB_point_parameters pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glPointParameterfvARB((GL.Enums.ARB_point_parameters)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightbv(GLint size, Byte* weights)
            {
                    {
                        Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightbv(GLint size, GLbyte* weights)
            {
                unsafe { Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights); }
            }
            
            public static 
            void Weightbv(GLint size, Byte[] weights)
            {
                unsafe
                {
                    fixed (Byte* weights_ptr = weights)
                    {
                        Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Weightbv(GLint size, GLbyte[] weights)
            {
                unsafe
                {
                    fixed (GLbyte* weights_ptr = weights)
                    {
                        Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights_ptr);
                    }
                }
            }
            
            public static 
            void Weightbv(GLint size, ref Byte weights)
            {
                unsafe
                {
                    fixed (Byte* weights_ptr = &weights)
                    {
                        Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Weightbv(GLint size, ref GLbyte weights)
            {
                unsafe
                {
                    fixed (GLbyte* weights_ptr = &weights)
                    {
                        Delegates.glWeightbvARB((GLint)size, (GLbyte*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightsv(GLint size, GLshort* weights)
            {
                unsafe { Delegates.glWeightsvARB((GLint)size, (GLshort*)weights); }
            }
            
            public static 
            void Weightsv(GLint size, GLshort[] weights)
            {
                unsafe
                {
                    fixed (GLshort* weights_ptr = weights)
                    {
                        Delegates.glWeightsvARB((GLint)size, (GLshort*)weights_ptr);
                    }
                }
            }
            
            public static 
            void Weightsv(GLint size, ref GLshort weights)
            {
                unsafe
                {
                    fixed (GLshort* weights_ptr = &weights)
                    {
                        Delegates.glWeightsvARB((GLint)size, (GLshort*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightiv(GLint size, GLint* weights)
            {
                unsafe { Delegates.glWeightivARB((GLint)size, (GLint*)weights); }
            }
            
            public static 
            void Weightiv(GLint size, GLint[] weights)
            {
                unsafe
                {
                    fixed (GLint* weights_ptr = weights)
                    {
                        Delegates.glWeightivARB((GLint)size, (GLint*)weights_ptr);
                    }
                }
            }
            
            public static 
            void Weightiv(GLint size, ref GLint weights)
            {
                unsafe
                {
                    fixed (GLint* weights_ptr = &weights)
                    {
                        Delegates.glWeightivARB((GLint)size, (GLint*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightfv(GLint size, GLfloat* weights)
            {
                unsafe { Delegates.glWeightfvARB((GLint)size, (GLfloat*)weights); }
            }
            
            public static 
            void Weightfv(GLint size, GLfloat[] weights)
            {
                unsafe
                {
                    fixed (GLfloat* weights_ptr = weights)
                    {
                        Delegates.glWeightfvARB((GLint)size, (GLfloat*)weights_ptr);
                    }
                }
            }
            
            public static 
            void Weightfv(GLint size, ref GLfloat weights)
            {
                unsafe
                {
                    fixed (GLfloat* weights_ptr = &weights)
                    {
                        Delegates.glWeightfvARB((GLint)size, (GLfloat*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightdv(GLint size, GLdouble* weights)
            {
                unsafe { Delegates.glWeightdvARB((GLint)size, (GLdouble*)weights); }
            }
            
            public static 
            void Weightdv(GLint size, GLdouble[] weights)
            {
                unsafe
                {
                    fixed (GLdouble* weights_ptr = weights)
                    {
                        Delegates.glWeightdvARB((GLint)size, (GLdouble*)weights_ptr);
                    }
                }
            }
            
            public static 
            void Weightdv(GLint size, ref GLdouble weights)
            {
                unsafe
                {
                    fixed (GLdouble* weights_ptr = &weights)
                    {
                        Delegates.glWeightdvARB((GLint)size, (GLdouble*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightubv(GLint size, GLubyte* weights)
            {
                unsafe { Delegates.glWeightubvARB((GLint)size, (GLubyte*)weights); }
            }
            
            public static 
            void Weightubv(GLint size, GLubyte[] weights)
            {
                unsafe
                {
                    fixed (GLubyte* weights_ptr = weights)
                    {
                        Delegates.glWeightubvARB((GLint)size, (GLubyte*)weights_ptr);
                    }
                }
            }
            
            public static 
            void Weightubv(GLint size, ref GLubyte weights)
            {
                unsafe
                {
                    fixed (GLubyte* weights_ptr = &weights)
                    {
                        Delegates.glWeightubvARB((GLint)size, (GLubyte*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightusv(GLint size, Int16* weights)
            {
                    {
                        Delegates.glWeightusvARB((GLint)size, (GLushort*)weights);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightusv(GLint size, GLushort* weights)
            {
                unsafe { Delegates.glWeightusvARB((GLint)size, (GLushort*)weights); }
            }
            
            public static 
            void Weightusv(GLint size, Int16[] weights)
            {
                unsafe
                {
                    fixed (Int16* weights_ptr = weights)
                    {
                        Delegates.glWeightusvARB((GLint)size, (GLushort*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Weightusv(GLint size, GLushort[] weights)
            {
                unsafe
                {
                    fixed (GLushort* weights_ptr = weights)
                    {
                        Delegates.glWeightusvARB((GLint)size, (GLushort*)weights_ptr);
                    }
                }
            }
            
            public static 
            void Weightusv(GLint size, ref Int16 weights)
            {
                unsafe
                {
                    fixed (Int16* weights_ptr = &weights)
                    {
                        Delegates.glWeightusvARB((GLint)size, (GLushort*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Weightusv(GLint size, ref GLushort weights)
            {
                unsafe
                {
                    fixed (GLushort* weights_ptr = &weights)
                    {
                        Delegates.glWeightusvARB((GLint)size, (GLushort*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightuiv(GLint size, Int32* weights)
            {
                    {
                        Delegates.glWeightuivARB((GLint)size, (GLuint*)weights);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Weightuiv(GLint size, GLuint* weights)
            {
                unsafe { Delegates.glWeightuivARB((GLint)size, (GLuint*)weights); }
            }
            
            public static 
            void Weightuiv(GLint size, Int32[] weights)
            {
                unsafe
                {
                    fixed (Int32* weights_ptr = weights)
                    {
                        Delegates.glWeightuivARB((GLint)size, (GLuint*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Weightuiv(GLint size, GLuint[] weights)
            {
                unsafe
                {
                    fixed (GLuint* weights_ptr = weights)
                    {
                        Delegates.glWeightuivARB((GLint)size, (GLuint*)weights_ptr);
                    }
                }
            }
            
            public static 
            void Weightuiv(GLint size, ref Int32 weights)
            {
                unsafe
                {
                    fixed (Int32* weights_ptr = &weights)
                    {
                        Delegates.glWeightuivARB((GLint)size, (GLuint*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Weightuiv(GLint size, ref GLuint weights)
            {
                unsafe
                {
                    fixed (GLuint* weights_ptr = &weights)
                    {
                        Delegates.glWeightuivARB((GLint)size, (GLuint*)weights_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WeightPointer(GLint size, GL.Enums.ARB_vertex_blend type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glWeightPointerARB((GLint)size, (GL.Enums.ARB_vertex_blend)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void WeightPointer(GLint size, GL.Enums.ARB_vertex_blend type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glWeightPointerARB((GLint)size, (GL.Enums.ARB_vertex_blend)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void VertexBlend(GLint count)
            {
                Delegates.glVertexBlendARB((GLint)count);
            }
            
            public static 
            void CurrentPaletteMatrix(GLint index)
            {
                Delegates.glCurrentPaletteMatrixARB((GLint)index);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndexubv(GLint size, GLubyte* indices)
            {
                unsafe { Delegates.glMatrixIndexubvARB((GLint)size, (GLubyte*)indices); }
            }
            
            public static 
            void MatrixIndexubv(GLint size, GLubyte[] indices)
            {
                unsafe
                {
                    fixed (GLubyte* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexubvARB((GLint)size, (GLubyte*)indices_ptr);
                    }
                }
            }
            
            public static 
            void MatrixIndexubv(GLint size, ref GLubyte indices)
            {
                unsafe
                {
                    fixed (GLubyte* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexubvARB((GLint)size, (GLubyte*)indices_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndexusv(GLint size, Int16* indices)
            {
                    {
                        Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndexusv(GLint size, GLushort* indices)
            {
                unsafe { Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices); }
            }
            
            public static 
            void MatrixIndexusv(GLint size, Int16[] indices)
            {
                unsafe
                {
                    fixed (Int16* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MatrixIndexusv(GLint size, GLushort[] indices)
            {
                unsafe
                {
                    fixed (GLushort* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices_ptr);
                    }
                }
            }
            
            public static 
            void MatrixIndexusv(GLint size, ref Int16 indices)
            {
                unsafe
                {
                    fixed (Int16* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MatrixIndexusv(GLint size, ref GLushort indices)
            {
                unsafe
                {
                    fixed (GLushort* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexusvARB((GLint)size, (GLushort*)indices_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndexuiv(GLint size, Int32* indices)
            {
                    {
                        Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndexuiv(GLint size, GLuint* indices)
            {
                unsafe { Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices); }
            }
            
            public static 
            void MatrixIndexuiv(GLint size, Int32[] indices)
            {
                unsafe
                {
                    fixed (Int32* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MatrixIndexuiv(GLint size, GLuint[] indices)
            {
                unsafe
                {
                    fixed (GLuint* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices_ptr);
                    }
                }
            }
            
            public static 
            void MatrixIndexuiv(GLint size, ref Int32 indices)
            {
                unsafe
                {
                    fixed (Int32* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MatrixIndexuiv(GLint size, ref GLuint indices)
            {
                unsafe
                {
                    fixed (GLuint* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexuivARB((GLint)size, (GLuint*)indices_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndexPointer(GLint size, GL.Enums.ARB_matrix_palette type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glMatrixIndexPointerARB((GLint)size, (GL.Enums.ARB_matrix_palette)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void MatrixIndexPointer(GLint size, GL.Enums.ARB_matrix_palette type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glMatrixIndexPointerARB((GLint)size, (GL.Enums.ARB_matrix_palette)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void WindowPos2d(GLdouble x, GLdouble y)
            {
                Delegates.glWindowPos2dARB((GLdouble)x, (GLdouble)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2dv(GLdouble* v)
            {
                unsafe { Delegates.glWindowPos2dvARB((GLdouble*)v); }
            }
            
            public static 
            void WindowPos2dv(GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glWindowPos2dvARB((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2dv(ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glWindowPos2dvARB((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2f(GLfloat x, GLfloat y)
            {
                Delegates.glWindowPos2fARB((GLfloat)x, (GLfloat)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2fv(GLfloat* v)
            {
                unsafe { Delegates.glWindowPos2fvARB((GLfloat*)v); }
            }
            
            public static 
            void WindowPos2fv(GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glWindowPos2fvARB((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2fv(ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glWindowPos2fvARB((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2i(GLint x, GLint y)
            {
                Delegates.glWindowPos2iARB((GLint)x, (GLint)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2iv(GLint* v)
            {
                unsafe { Delegates.glWindowPos2ivARB((GLint*)v); }
            }
            
            public static 
            void WindowPos2iv(GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glWindowPos2ivARB((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2iv(ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glWindowPos2ivARB((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2s(GLshort x, GLshort y)
            {
                Delegates.glWindowPos2sARB((GLshort)x, (GLshort)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2sv(GLshort* v)
            {
                unsafe { Delegates.glWindowPos2svARB((GLshort*)v); }
            }
            
            public static 
            void WindowPos2sv(GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glWindowPos2svARB((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2sv(ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glWindowPos2svARB((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
            {
                Delegates.glWindowPos3dARB((GLdouble)x, (GLdouble)y, (GLdouble)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3dv(GLdouble* v)
            {
                unsafe { Delegates.glWindowPos3dvARB((GLdouble*)v); }
            }
            
            public static 
            void WindowPos3dv(GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glWindowPos3dvARB((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3dv(ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glWindowPos3dvARB((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glWindowPos3fARB((GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3fv(GLfloat* v)
            {
                unsafe { Delegates.glWindowPos3fvARB((GLfloat*)v); }
            }
            
            public static 
            void WindowPos3fv(GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glWindowPos3fvARB((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3fv(ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glWindowPos3fvARB((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3i(GLint x, GLint y, GLint z)
            {
                Delegates.glWindowPos3iARB((GLint)x, (GLint)y, (GLint)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3iv(GLint* v)
            {
                unsafe { Delegates.glWindowPos3ivARB((GLint*)v); }
            }
            
            public static 
            void WindowPos3iv(GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glWindowPos3ivARB((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3iv(ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glWindowPos3ivARB((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3s(GLshort x, GLshort y, GLshort z)
            {
                Delegates.glWindowPos3sARB((GLshort)x, (GLshort)y, (GLshort)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3sv(GLshort* v)
            {
                unsafe { Delegates.glWindowPos3svARB((GLshort*)v); }
            }
            
            public static 
            void WindowPos3sv(GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glWindowPos3svARB((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3sv(ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glWindowPos3svARB((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1d(Int32 index, GLdouble x)
            {
                Delegates.glVertexAttrib1dARB((GLuint)index, (GLdouble)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1d(GLuint index, GLdouble x)
            {
                Delegates.glVertexAttrib1dARB((GLuint)index, (GLdouble)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1dv(Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1dv(GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttrib1dv(Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1dv(GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1dv(Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1dv(GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1f(Int32 index, GLfloat x)
            {
                Delegates.glVertexAttrib1fARB((GLuint)index, (GLfloat)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1f(GLuint index, GLfloat x)
            {
                Delegates.glVertexAttrib1fARB((GLuint)index, (GLfloat)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1fv(Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1fv(GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttrib1fv(Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1fv(GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1fv(Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1fv(GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1s(Int32 index, GLshort x)
            {
                Delegates.glVertexAttrib1sARB((GLuint)index, (GLshort)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1s(GLuint index, GLshort x)
            {
                Delegates.glVertexAttrib1sARB((GLuint)index, (GLshort)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib1sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2d(Int32 index, GLdouble x, GLdouble y)
            {
                Delegates.glVertexAttrib2dARB((GLuint)index, (GLdouble)x, (GLdouble)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
            {
                Delegates.glVertexAttrib2dARB((GLuint)index, (GLdouble)x, (GLdouble)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2dv(Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2dv(GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttrib2dv(Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2dv(GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2dv(Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2dv(GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2f(Int32 index, GLfloat x, GLfloat y)
            {
                Delegates.glVertexAttrib2fARB((GLuint)index, (GLfloat)x, (GLfloat)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
            {
                Delegates.glVertexAttrib2fARB((GLuint)index, (GLfloat)x, (GLfloat)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2fv(Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2fv(GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttrib2fv(Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2fv(GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2fv(Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2fv(GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2s(Int32 index, GLshort x, GLshort y)
            {
                Delegates.glVertexAttrib2sARB((GLuint)index, (GLshort)x, (GLshort)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2s(GLuint index, GLshort x, GLshort y)
            {
                Delegates.glVertexAttrib2sARB((GLuint)index, (GLshort)x, (GLshort)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib2sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3d(Int32 index, GLdouble x, GLdouble y, GLdouble z)
            {
                Delegates.glVertexAttrib3dARB((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
            {
                Delegates.glVertexAttrib3dARB((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3dv(Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3dv(GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttrib3dv(Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3dv(GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3dv(Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3dv(GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3f(Int32 index, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glVertexAttrib3fARB((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glVertexAttrib3fARB((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3fv(Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3fv(GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttrib3fv(Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3fv(GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3fv(Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3fv(GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3s(Int32 index, GLshort x, GLshort y, GLshort z)
            {
                Delegates.glVertexAttrib3sARB((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
            {
                Delegates.glVertexAttrib3sARB((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib3sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nbv(Int32 index, Byte* v)
            {
                    {
                        Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nbv(GLuint index, GLbyte* v)
            {
                unsafe { Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v); }
            }
            
            public static 
            void VertexAttrib4Nbv(Int32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nbv(GLuint index, GLbyte[] v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4Nbv(Int32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nbv(GLuint index, ref GLbyte v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NbvARB((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Niv(Int32 index, GLint* v)
            {
                    {
                        Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Niv(GLuint index, GLint* v)
            {
                unsafe { Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v); }
            }
            
            public static 
            void VertexAttrib4Niv(Int32 index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Niv(GLuint index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4Niv(Int32 index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Niv(GLuint index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NivARB((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nsv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nsv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib4Nsv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nsv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4Nsv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nsv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NsvARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4Nub(Int32 index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
            {
                Delegates.glVertexAttrib4NubARB((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
            {
                Delegates.glVertexAttrib4NubARB((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nubv(Int32 index, GLubyte* v)
            {
                    {
                        Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nubv(GLuint index, GLubyte* v)
            {
                unsafe { Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v); }
            }
            
            public static 
            void VertexAttrib4Nubv(Int32 index, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nubv(GLuint index, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4Nubv(Int32 index, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nubv(GLuint index, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NubvARB((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nuiv(Int32 index, Int32* v)
            {
                    {
                        Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nuiv(GLuint index, GLuint* v)
            {
                unsafe { Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v); }
            }
            
            public static 
            void VertexAttrib4Nuiv(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nuiv(GLuint index, GLuint[] v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4Nuiv(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nuiv(GLuint index, ref GLuint v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NuivARB((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nusv(Int32 index, Int16* v)
            {
                    {
                        Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4Nusv(GLuint index, GLushort* v)
            {
                unsafe { Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v); }
            }
            
            public static 
            void VertexAttrib4Nusv(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nusv(GLuint index, GLushort[] v)
            {
                unsafe
                {
                    fixed (GLushort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4Nusv(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4Nusv(GLuint index, ref GLushort v)
            {
                unsafe
                {
                    fixed (GLushort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NusvARB((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4bv(Int32 index, Byte* v)
            {
                    {
                        Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4bv(GLuint index, GLbyte* v)
            {
                unsafe { Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v); }
            }
            
            public static 
            void VertexAttrib4bv(Int32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4bv(GLuint index, GLbyte[] v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4bv(Int32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4bv(GLuint index, ref GLbyte v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4bvARB((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4d(Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glVertexAttrib4dARB((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glVertexAttrib4dARB((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4dv(Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4dv(GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttrib4dv(Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4dv(GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4dv(Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4dv(GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4dvARB((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4f(Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glVertexAttrib4fARB((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glVertexAttrib4fARB((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4fv(Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4fv(GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttrib4fv(Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4fv(GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4fv(Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4fv(GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4fvARB((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4iv(Int32 index, GLint* v)
            {
                    {
                        Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4iv(GLuint index, GLint* v)
            {
                unsafe { Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v); }
            }
            
            public static 
            void VertexAttrib4iv(Int32 index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4iv(GLuint index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4iv(Int32 index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4iv(GLuint index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ivARB((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4s(Int32 index, GLshort x, GLshort y, GLshort z, GLshort w)
            {
                Delegates.glVertexAttrib4sARB((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
            {
                Delegates.glVertexAttrib4sARB((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib4sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4svARB((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4ubv(Int32 index, GLubyte* v)
            {
                    {
                        Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4ubv(GLuint index, GLubyte* v)
            {
                unsafe { Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v); }
            }
            
            public static 
            void VertexAttrib4ubv(Int32 index, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4ubv(GLuint index, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4ubv(Int32 index, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4ubv(GLuint index, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ubvARB((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4uiv(Int32 index, Int32* v)
            {
                    {
                        Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4uiv(GLuint index, GLuint* v)
            {
                unsafe { Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v); }
            }
            
            public static 
            void VertexAttrib4uiv(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4uiv(GLuint index, GLuint[] v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4uiv(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4uiv(GLuint index, ref GLuint v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4uivARB((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4usv(Int32 index, Int16* v)
            {
                    {
                        Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4usv(GLuint index, GLushort* v)
            {
                unsafe { Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v); }
            }
            
            public static 
            void VertexAttrib4usv(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4usv(GLuint index, GLushort[] v)
            {
                unsafe
                {
                    fixed (GLushort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4usv(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4usv(GLuint index, ref GLushort v)
            {
                unsafe
                {
                    fixed (GLushort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4usvARB((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribPointer(Int32 index, GLint size, GL.Enums.ARB_vertex_program type, GL.Enums.Boolean normalized, GLsizei stride, void* pointer)
            {
                    {
                        Delegates.glVertexAttribPointerARB((GLuint)index, (GLint)size, (GL.Enums.ARB_vertex_program)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (void*)pointer);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribPointer(GLuint index, GLint size, GL.Enums.ARB_vertex_program type, GL.Enums.Boolean normalized, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glVertexAttribPointerARB((GLuint)index, (GLint)size, (GL.Enums.ARB_vertex_program)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void EnableVertexAttribArray(Int32 index)
            {
                Delegates.glEnableVertexAttribArrayARB((GLuint)index);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void EnableVertexAttribArray(GLuint index)
            {
                Delegates.glEnableVertexAttribArrayARB((GLuint)index);
            }
            
            public static 
            void DisableVertexAttribArray(Int32 index)
            {
                Delegates.glDisableVertexAttribArrayARB((GLuint)index);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DisableVertexAttribArray(GLuint index)
            {
                Delegates.glDisableVertexAttribArrayARB((GLuint)index);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramString(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program format, GLsizei len, void* @string)
            {
                unsafe { Delegates.glProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)format, (GLsizei)len, (void*)@string); }
            }
            
            public static 
            void ProgramString(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program format, GLsizei len, object @string)
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)format, (GLsizei)len, (void*)@string_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        @string_ptr.Free();
                    }
                }
            }
            
            public static 
            void BindProgram(GL.Enums.ARB_vertex_program target, Int32 program)
            {
                Delegates.glBindProgramARB((GL.Enums.ARB_vertex_program)target, (GLuint)program);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindProgram(GL.Enums.ARB_vertex_program target, GLuint program)
            {
                Delegates.glBindProgramARB((GL.Enums.ARB_vertex_program)target, (GLuint)program);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeletePrograms(GLsizei n, Int32* programs)
            {
                    {
                        Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeletePrograms(GLsizei n, GLuint* programs)
            {
                unsafe { Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs); }
            }
            
            public static 
            void DeletePrograms(GLsizei n, Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeletePrograms(GLsizei n, GLuint[] programs)
            {
                unsafe
                {
                    fixed (GLuint* programs_ptr = programs)
                    {
                        Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            public static 
            void DeletePrograms(GLsizei n, ref Int32 programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeletePrograms(GLsizei n, ref GLuint programs)
            {
                unsafe
                {
                    fixed (GLuint* programs_ptr = &programs)
                    {
                        Delegates.glDeleteProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenPrograms(GLsizei n, Int32* programs)
            {
                programs = default(Int32*);
                    {
                        Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenPrograms(GLsizei n, GLuint* programs)
            {
                unsafe { Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs); }
            }
            
            public static 
            void GenPrograms(GLsizei n, Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenPrograms(GLsizei n, GLuint[] programs)
            {
                unsafe
                {
                    fixed (GLuint* programs_ptr = programs)
                    {
                        Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            public static 
            void GenPrograms(GLsizei n, out Int32 programs)
            {
                programs = default(Int32);
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
                        programs = *programs_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenPrograms(GLsizei n, out GLuint programs)
            {
                programs = default(GLuint);
                unsafe
                {
                    fixed (GLuint* programs_ptr = &programs)
                    {
                        Delegates.glGenProgramsARB((GLsizei)n, (GLuint*)programs_ptr);
                        programs = *programs_ptr;
                    }
                }
            }
            
            public static 
            void ProgramEnvParameter4d(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glProgramEnvParameter4dARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4d(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glProgramEnvParameter4dARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble* @params)
            {
                    {
                        Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble* @params)
            {
                unsafe { Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params); }
            }
            
            public static 
            void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, ref GLdouble @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, ref GLdouble @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParameter4f(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glProgramEnvParameter4fARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4f(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glProgramEnvParameter4fARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat* @params)
            {
                    {
                        Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat* @params)
            {
                unsafe { Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params); }
            }
            
            public static 
            void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParameter4d(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glProgramLocalParameter4dARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4d(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glProgramLocalParameter4dARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble* @params)
            {
                    {
                        Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble* @params)
            {
                unsafe { Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params); }
            }
            
            public static 
            void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, Int32 index, ref GLdouble @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4dv(GL.Enums.ARB_vertex_program target, GLuint index, ref GLdouble @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameter4dvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParameter4f(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glProgramLocalParameter4fARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4f(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glProgramLocalParameter4fARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat* @params)
            {
                    {
                        Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat* @params)
            {
                unsafe { Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params); }
            }
            
            public static 
            void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, Int32 index, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4fv(GL.Enums.ARB_vertex_program target, GLuint index, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameter4fvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    {
                        Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble* @params)
            {
                unsafe { Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params); }
            }
            
            public static 
            void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat* @params)
            {
                unsafe { Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params); }
            }
            
            public static 
            void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    {
                        Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble* @params)
            {
                unsafe { Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params); }
            }
            
            public static 
            void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, Int32 index, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterdv(GL.Enums.ARB_vertex_program target, GLuint index, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterdvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat* @params)
            {
                unsafe { Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params); }
            }
            
            public static 
            void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, Int32 index, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterfv(GL.Enums.ARB_vertex_program target, GLuint index, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterfvARB((GL.Enums.ARB_vertex_program)target, (GLuint)index, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramiv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, GLint* @params)
            {
                unsafe { Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params); }
            }
            
            public static 
            void GetProgramiv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramiv(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramivARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramString(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, void* @string)
            {
                unsafe { Delegates.glGetProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (void*)@string); }
            }
            
            public static 
            void GetProgramString(GL.Enums.ARB_vertex_program target, GL.Enums.ARB_vertex_program pname, object @string)
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetProgramStringARB((GL.Enums.ARB_vertex_program)target, (GL.Enums.ARB_vertex_program)pname, (void*)@string_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        @string_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribdv(Int32 index, GL.Enums.ARB_vertex_program pname, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    {
                        Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribdv(GLuint index, GL.Enums.ARB_vertex_program pname, GLdouble* @params)
            {
                unsafe { Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params); }
            }
            
            public static 
            void GetVertexAttribdv(Int32 index, GL.Enums.ARB_vertex_program pname, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribdv(GLuint index, GL.Enums.ARB_vertex_program pname, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribdv(Int32 index, GL.Enums.ARB_vertex_program pname, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribdv(GLuint index, GL.Enums.ARB_vertex_program pname, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribdvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribfv(Int32 index, GL.Enums.ARB_vertex_program pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribfv(GLuint index, GL.Enums.ARB_vertex_program pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetVertexAttribfv(Int32 index, GL.Enums.ARB_vertex_program pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribfv(GLuint index, GL.Enums.ARB_vertex_program pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribfv(Int32 index, GL.Enums.ARB_vertex_program pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribfv(GLuint index, GL.Enums.ARB_vertex_program pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribfvARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribiv(Int32 index, GL.Enums.ARB_vertex_program pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribiv(GLuint index, GL.Enums.ARB_vertex_program pname, GLint* @params)
            {
                unsafe { Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params); }
            }
            
            public static 
            void GetVertexAttribiv(Int32 index, GL.Enums.ARB_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribiv(GLuint index, GL.Enums.ARB_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribiv(Int32 index, GL.Enums.ARB_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribiv(GLuint index, GL.Enums.ARB_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribivARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribPointerv(Int32 index, GL.Enums.ARB_vertex_program pname, void* pointer)
            {
                pointer = default(void*);
                    {
                        Delegates.glGetVertexAttribPointervARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribPointerv(GLuint index, GL.Enums.ARB_vertex_program pname, void* pointer)
            {
                unsafe { Delegates.glGetVertexAttribPointervARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer); }
            }
            
            public static 
            void GetVertexAttribPointerv(Int32 index, GL.Enums.ARB_vertex_program pname, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetVertexAttribPointervARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribPointerv(GLuint index, GL.Enums.ARB_vertex_program pname, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetVertexAttribPointervARB((GLuint)index, (GL.Enums.ARB_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            GLboolean IsProgram(Int32 program)
            {
                return Delegates.glIsProgramARB((GLuint)program);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsProgram(GLuint program)
            {
                return Delegates.glIsProgramARB((GLuint)program);
            }
            
            public static 
            void BindBuffer(GL.Enums.ARB_vertex_buffer_object target, Int32 buffer)
            {
                Delegates.glBindBufferARB((GL.Enums.ARB_vertex_buffer_object)target, (GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindBuffer(GL.Enums.ARB_vertex_buffer_object target, GLuint buffer)
            {
                Delegates.glBindBufferARB((GL.Enums.ARB_vertex_buffer_object)target, (GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteBuffers(GLsizei n, Int32* buffers)
            {
                    {
                        Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteBuffers(GLsizei n, GLuint* buffers)
            {
                unsafe { Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers); }
            }
            
            public static 
            void DeleteBuffers(GLsizei n, Int32[] buffers)
            {
                unsafe
                {
                    fixed (Int32* buffers_ptr = buffers)
                    {
                        Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteBuffers(GLsizei n, GLuint[] buffers)
            {
                unsafe
                {
                    fixed (GLuint* buffers_ptr = buffers)
                    {
                        Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
                    }
                }
            }
            
            public static 
            void DeleteBuffers(GLsizei n, ref Int32 buffers)
            {
                unsafe
                {
                    fixed (Int32* buffers_ptr = &buffers)
                    {
                        Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteBuffers(GLsizei n, ref GLuint buffers)
            {
                unsafe
                {
                    fixed (GLuint* buffers_ptr = &buffers)
                    {
                        Delegates.glDeleteBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenBuffers(GLsizei n, Int32* buffers)
            {
                buffers = default(Int32*);
                    {
                        Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenBuffers(GLsizei n, GLuint* buffers)
            {
                unsafe { Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers); }
            }
            
            public static 
            void GenBuffers(GLsizei n, Int32[] buffers)
            {
                unsafe
                {
                    fixed (Int32* buffers_ptr = buffers)
                    {
                        Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenBuffers(GLsizei n, GLuint[] buffers)
            {
                unsafe
                {
                    fixed (GLuint* buffers_ptr = buffers)
                    {
                        Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
                    }
                }
            }
            
            public static 
            void GenBuffers(GLsizei n, out Int32 buffers)
            {
                buffers = default(Int32);
                unsafe
                {
                    fixed (Int32* buffers_ptr = &buffers)
                    {
                        Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
                        buffers = *buffers_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenBuffers(GLsizei n, out GLuint buffers)
            {
                buffers = default(GLuint);
                unsafe
                {
                    fixed (GLuint* buffers_ptr = &buffers)
                    {
                        Delegates.glGenBuffersARB((GLsizei)n, (GLuint*)buffers_ptr);
                        buffers = *buffers_ptr;
                    }
                }
            }
            
            public static 
            GLboolean IsBuffer(Int32 buffer)
            {
                return Delegates.glIsBufferARB((GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsBuffer(GLuint buffer)
            {
                return Delegates.glIsBufferARB((GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void BufferData(GL.Enums.ARB_vertex_buffer_object target, GLsizeiptrARB size, void* data, GL.Enums.ARB_vertex_buffer_object usage)
            {
                unsafe { Delegates.glBufferDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLsizeiptrARB)size, (void*)data, (GL.Enums.ARB_vertex_buffer_object)usage); }
            }
            
            public static 
            void BufferData(GL.Enums.ARB_vertex_buffer_object target, GLsizeiptrARB size, object data, GL.Enums.ARB_vertex_buffer_object usage)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glBufferDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLsizeiptrARB)size, (void*)data_ptr.AddrOfPinnedObject(), (GL.Enums.ARB_vertex_buffer_object)usage);
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void BufferSubData(GL.Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, void* data)
            {
                unsafe { Delegates.glBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLintptrARB)offset, (GLsizeiptrARB)size, (void*)data); }
            }
            
            public static 
            void BufferSubData(GL.Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLintptrARB)offset, (GLsizeiptrARB)size, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetBufferSubData(GL.Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, void* data)
            {
                unsafe { Delegates.glGetBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLintptrARB)offset, (GLsizeiptrARB)size, (void*)data); }
            }
            
            public static 
            void GetBufferSubData(GL.Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetBufferSubDataARB((GL.Enums.ARB_vertex_buffer_object)target, (GLintptrARB)offset, (GLsizeiptrARB)size, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            public static 
            IntPtr MapBuffer(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object access)
            {
                 return Delegates.glMapBufferARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)access); 
            }
            
            public static 
            GLboolean UnmapBuffer(GL.Enums.ARB_vertex_buffer_object target)
            {
                return Delegates.glUnmapBufferARB((GL.Enums.ARB_vertex_buffer_object)target);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetBufferParameteriv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, GLint* @params)
            {
                unsafe { Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (GLint*)@params); }
            }
            
            public static 
            void GetBufferParameteriv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetBufferParameteriv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetBufferParameterivARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetBufferPointerv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, void* @params)
            {
                unsafe { Delegates.glGetBufferPointervARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (void*)@params); }
            }
            
            public static 
            void GetBufferPointerv(GL.Enums.ARB_vertex_buffer_object target, GL.Enums.ARB_vertex_buffer_object pname, object @params)
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetBufferPointervARB((GL.Enums.ARB_vertex_buffer_object)target, (GL.Enums.ARB_vertex_buffer_object)pname, (void*)@params_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        @params_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenQueries(GLsizei n, Int32* ids)
            {
                ids = default(Int32*);
                    {
                        Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenQueries(GLsizei n, GLuint* ids)
            {
                unsafe { Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids); }
            }
            
            public static 
            void GenQueries(GLsizei n, Int32[] ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = ids)
                    {
                        Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenQueries(GLsizei n, GLuint[] ids)
            {
                unsafe
                {
                    fixed (GLuint* ids_ptr = ids)
                    {
                        Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            public static 
            void GenQueries(GLsizei n, out Int32 ids)
            {
                ids = default(Int32);
                unsafe
                {
                    fixed (Int32* ids_ptr = &ids)
                    {
                        Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
                        ids = *ids_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenQueries(GLsizei n, out GLuint ids)
            {
                ids = default(GLuint);
                unsafe
                {
                    fixed (GLuint* ids_ptr = &ids)
                    {
                        Delegates.glGenQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
                        ids = *ids_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteQueries(GLsizei n, Int32* ids)
            {
                    {
                        Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteQueries(GLsizei n, GLuint* ids)
            {
                unsafe { Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids); }
            }
            
            public static 
            void DeleteQueries(GLsizei n, Int32[] ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = ids)
                    {
                        Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteQueries(GLsizei n, GLuint[] ids)
            {
                unsafe
                {
                    fixed (GLuint* ids_ptr = ids)
                    {
                        Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            public static 
            void DeleteQueries(GLsizei n, ref Int32 ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = &ids)
                    {
                        Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteQueries(GLsizei n, ref GLuint ids)
            {
                unsafe
                {
                    fixed (GLuint* ids_ptr = &ids)
                    {
                        Delegates.glDeleteQueriesARB((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            public static 
            GLboolean IsQuery(Int32 id)
            {
                return Delegates.glIsQueryARB((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsQuery(GLuint id)
            {
                return Delegates.glIsQueryARB((GLuint)id);
            }
            
            public static 
            void BeginQuery(GL.Enums.ARB_occlusion_query target, Int32 id)
            {
                Delegates.glBeginQueryARB((GL.Enums.ARB_occlusion_query)target, (GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BeginQuery(GL.Enums.ARB_occlusion_query target, GLuint id)
            {
                Delegates.glBeginQueryARB((GL.Enums.ARB_occlusion_query)target, (GLuint)id);
            }
            
            public static 
            void EndQuery(GL.Enums.ARB_occlusion_query target)
            {
                Delegates.glEndQueryARB((GL.Enums.ARB_occlusion_query)target);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryiv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, GLint* @params)
            {
                unsafe { Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params); }
            }
            
            public static 
            void GetQueryiv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetQueryiv(GL.Enums.ARB_occlusion_query target, GL.Enums.ARB_occlusion_query pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryivARB((GL.Enums.ARB_occlusion_query)target, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjectiv(Int32 id, GL.Enums.ARB_occlusion_query pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjectiv(GLuint id, GL.Enums.ARB_occlusion_query pname, GLint* @params)
            {
                unsafe { Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params); }
            }
            
            public static 
            void GetQueryObjectiv(Int32 id, GL.Enums.ARB_occlusion_query pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjectiv(GLuint id, GL.Enums.ARB_occlusion_query pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetQueryObjectiv(Int32 id, GL.Enums.ARB_occlusion_query pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjectiv(GLuint id, GL.Enums.ARB_occlusion_query pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjectuiv(Int32 id, GL.Enums.ARB_occlusion_query pname, Int32* @params)
            {
                @params = default(Int32*);
                    {
                        Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjectuiv(GLuint id, GL.Enums.ARB_occlusion_query pname, GLuint* @params)
            {
                unsafe { Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params); }
            }
            
            public static 
            void GetQueryObjectuiv(Int32 id, GL.Enums.ARB_occlusion_query pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjectuiv(GLuint id, GL.Enums.ARB_occlusion_query pname, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetQueryObjectuiv(Int32 id, GL.Enums.ARB_occlusion_query pname, out Int32 @params)
            {
                @params = default(Int32);
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjectuiv(GLuint id, GL.Enums.ARB_occlusion_query pname, out GLuint @params)
            {
                @params = default(GLuint);
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectuivARB((GLuint)id, (GL.Enums.ARB_occlusion_query)pname, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void DeleteObject(Int32 obj)
            {
                Delegates.glDeleteObjectARB((GLhandleARB)obj);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteObject(GLhandleARB obj)
            {
                Delegates.glDeleteObjectARB((GLhandleARB)obj);
            }
            
            public static 
            Int32 GetHandle(GL.Enums.ARB_shader_objects pname)
            {
                return Delegates.glGetHandleARB((GL.Enums.ARB_shader_objects)pname);
            }
            
            public static 
            void DetachObject(Int32 containerObj, Int32 attachedObj)
            {
                Delegates.glDetachObjectARB((GLhandleARB)containerObj, (GLhandleARB)attachedObj);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DetachObject(GLhandleARB containerObj, GLhandleARB attachedObj)
            {
                Delegates.glDetachObjectARB((GLhandleARB)containerObj, (GLhandleARB)attachedObj);
            }
            
            public static 
            Int32 CreateShaderObject(GL.Enums.ARB_shader_objects shaderType)
            {
                return Delegates.glCreateShaderObjectARB((GL.Enums.ARB_shader_objects)shaderType);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ShaderSource(Int32 shaderObj, GLsizei count, System.String[] @string, GLint* length)
            {
                    {
                        Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ShaderSource(GLhandleARB shaderObj, GLsizei count, System.String[] @string, GLint* length)
            {
                unsafe { Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length); }
            }
            
            public static 
            void ShaderSource(Int32 shaderObj, GLsizei count, System.String[] @string, GLint[] length)
            {
                unsafe
                {
                    fixed (GLint* length_ptr = length)
                    {
                        Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ShaderSource(GLhandleARB shaderObj, GLsizei count, System.String[] @string, GLint[] length)
            {
                unsafe
                {
                    fixed (GLint* length_ptr = length)
                    {
                        Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
                    }
                }
            }
            
            public static 
            void ShaderSource(Int32 shaderObj, GLsizei count, System.String[] @string, ref GLint length)
            {
                unsafe
                {
                    fixed (GLint* length_ptr = &length)
                    {
                        Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ShaderSource(GLhandleARB shaderObj, GLsizei count, System.String[] @string, ref GLint length)
            {
                unsafe
                {
                    fixed (GLint* length_ptr = &length)
                    {
                        Delegates.glShaderSourceARB((GLhandleARB)shaderObj, (GLsizei)count, (System.String[])@string, (GLint*)length_ptr);
                    }
                }
            }
            
            public static 
            void CompileShader(Int32 shaderObj)
            {
                Delegates.glCompileShaderARB((GLhandleARB)shaderObj);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void CompileShader(GLhandleARB shaderObj)
            {
                Delegates.glCompileShaderARB((GLhandleARB)shaderObj);
            }
            
            public static 
            Int32 CreateProgramObject()
            {
                return Delegates.glCreateProgramObjectARB();
            }
            
            public static 
            void AttachObject(Int32 containerObj, Int32 obj)
            {
                Delegates.glAttachObjectARB((GLhandleARB)containerObj, (GLhandleARB)obj);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void AttachObject(GLhandleARB containerObj, GLhandleARB obj)
            {
                Delegates.glAttachObjectARB((GLhandleARB)containerObj, (GLhandleARB)obj);
            }
            
            public static 
            void LinkProgram(Int32 programObj)
            {
                Delegates.glLinkProgramARB((GLhandleARB)programObj);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void LinkProgram(GLhandleARB programObj)
            {
                Delegates.glLinkProgramARB((GLhandleARB)programObj);
            }
            
            public static 
            void UseProgramObject(Int32 programObj)
            {
                Delegates.glUseProgramObjectARB((GLhandleARB)programObj);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void UseProgramObject(GLhandleARB programObj)
            {
                Delegates.glUseProgramObjectARB((GLhandleARB)programObj);
            }
            
            public static 
            void ValidateProgram(Int32 programObj)
            {
                Delegates.glValidateProgramARB((GLhandleARB)programObj);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ValidateProgram(GLhandleARB programObj)
            {
                Delegates.glValidateProgramARB((GLhandleARB)programObj);
            }
            
            public static 
            void Uniform1f(GLint location, GLfloat v0)
            {
                Delegates.glUniform1fARB((GLint)location, (GLfloat)v0);
            }
            
            public static 
            void Uniform2f(GLint location, GLfloat v0, GLfloat v1)
            {
                Delegates.glUniform2fARB((GLint)location, (GLfloat)v0, (GLfloat)v1);
            }
            
            public static 
            void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
            {
                Delegates.glUniform3fARB((GLint)location, (GLfloat)v0, (GLfloat)v1, (GLfloat)v2);
            }
            
            public static 
            void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
            {
                Delegates.glUniform4fARB((GLint)location, (GLfloat)v0, (GLfloat)v1, (GLfloat)v2, (GLfloat)v3);
            }
            
            public static 
            void Uniform1i(GLint location, GLint v0)
            {
                Delegates.glUniform1iARB((GLint)location, (GLint)v0);
            }
            
            public static 
            void Uniform2i(GLint location, GLint v0, GLint v1)
            {
                Delegates.glUniform2iARB((GLint)location, (GLint)v0, (GLint)v1);
            }
            
            public static 
            void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
            {
                Delegates.glUniform3iARB((GLint)location, (GLint)v0, (GLint)v1, (GLint)v2);
            }
            
            public static 
            void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
            {
                Delegates.glUniform4iARB((GLint)location, (GLint)v0, (GLint)v1, (GLint)v2, (GLint)v3);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform1fv(GLint location, GLsizei count, GLfloat* value)
            {
                unsafe { Delegates.glUniform1fvARB((GLint)location, (GLsizei)count, (GLfloat*)value); }
            }
            
            public static 
            void Uniform1fv(GLint location, GLsizei count, GLfloat[] value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = value)
                    {
                        Delegates.glUniform1fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform1fv(GLint location, GLsizei count, ref GLfloat value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = &value)
                    {
                        Delegates.glUniform1fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform2fv(GLint location, GLsizei count, GLfloat* value)
            {
                unsafe { Delegates.glUniform2fvARB((GLint)location, (GLsizei)count, (GLfloat*)value); }
            }
            
            public static 
            void Uniform2fv(GLint location, GLsizei count, GLfloat[] value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = value)
                    {
                        Delegates.glUniform2fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform2fv(GLint location, GLsizei count, ref GLfloat value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = &value)
                    {
                        Delegates.glUniform2fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform3fv(GLint location, GLsizei count, GLfloat* value)
            {
                unsafe { Delegates.glUniform3fvARB((GLint)location, (GLsizei)count, (GLfloat*)value); }
            }
            
            public static 
            void Uniform3fv(GLint location, GLsizei count, GLfloat[] value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = value)
                    {
                        Delegates.glUniform3fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform3fv(GLint location, GLsizei count, ref GLfloat value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = &value)
                    {
                        Delegates.glUniform3fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform4fv(GLint location, GLsizei count, GLfloat* value)
            {
                unsafe { Delegates.glUniform4fvARB((GLint)location, (GLsizei)count, (GLfloat*)value); }
            }
            
            public static 
            void Uniform4fv(GLint location, GLsizei count, GLfloat[] value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = value)
                    {
                        Delegates.glUniform4fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform4fv(GLint location, GLsizei count, ref GLfloat value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = &value)
                    {
                        Delegates.glUniform4fvARB((GLint)location, (GLsizei)count, (GLfloat*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform1iv(GLint location, GLsizei count, GLint* value)
            {
                unsafe { Delegates.glUniform1ivARB((GLint)location, (GLsizei)count, (GLint*)value); }
            }
            
            public static 
            void Uniform1iv(GLint location, GLsizei count, GLint[] value)
            {
                unsafe
                {
                    fixed (GLint* value_ptr = value)
                    {
                        Delegates.glUniform1ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform1iv(GLint location, GLsizei count, ref GLint value)
            {
                unsafe
                {
                    fixed (GLint* value_ptr = &value)
                    {
                        Delegates.glUniform1ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform2iv(GLint location, GLsizei count, GLint* value)
            {
                unsafe { Delegates.glUniform2ivARB((GLint)location, (GLsizei)count, (GLint*)value); }
            }
            
            public static 
            void Uniform2iv(GLint location, GLsizei count, GLint[] value)
            {
                unsafe
                {
                    fixed (GLint* value_ptr = value)
                    {
                        Delegates.glUniform2ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform2iv(GLint location, GLsizei count, ref GLint value)
            {
                unsafe
                {
                    fixed (GLint* value_ptr = &value)
                    {
                        Delegates.glUniform2ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform3iv(GLint location, GLsizei count, GLint* value)
            {
                unsafe { Delegates.glUniform3ivARB((GLint)location, (GLsizei)count, (GLint*)value); }
            }
            
            public static 
            void Uniform3iv(GLint location, GLsizei count, GLint[] value)
            {
                unsafe
                {
                    fixed (GLint* value_ptr = value)
                    {
                        Delegates.glUniform3ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform3iv(GLint location, GLsizei count, ref GLint value)
            {
                unsafe
                {
                    fixed (GLint* value_ptr = &value)
                    {
                        Delegates.glUniform3ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform4iv(GLint location, GLsizei count, GLint* value)
            {
                unsafe { Delegates.glUniform4ivARB((GLint)location, (GLsizei)count, (GLint*)value); }
            }
            
            public static 
            void Uniform4iv(GLint location, GLsizei count, GLint[] value)
            {
                unsafe
                {
                    fixed (GLint* value_ptr = value)
                    {
                        Delegates.glUniform4ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform4iv(GLint location, GLsizei count, ref GLint value)
            {
                unsafe
                {
                    fixed (GLint* value_ptr = &value)
                    {
                        Delegates.glUniform4ivARB((GLint)location, (GLsizei)count, (GLint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void UniformMatrix2fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
            {
                unsafe { Delegates.glUniformMatrix2fvARB((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void UniformMatrix3fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
            {
                unsafe { Delegates.glUniformMatrix3fvARB((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void UniformMatrix4fv(GLint location, GLsizei count, GL.Enums.Boolean transpose, GLfloat* value)
            {
                unsafe { Delegates.glUniformMatrix4fvARB((GLint)location, (GLsizei)count, (GL.Enums.Boolean)transpose, (GLfloat*)value); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectParameterfv(Int32 obj, GL.Enums.ARB_shader_objects pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectParameterfv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetObjectParameterfv(Int32 obj, GL.Enums.ARB_shader_objects pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetObjectParameterfv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetObjectParameterfv(Int32 obj, GL.Enums.ARB_shader_objects pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetObjectParameterfv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectParameterfvARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectParameteriv(Int32 obj, GL.Enums.ARB_shader_objects pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectParameteriv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, GLint* @params)
            {
                unsafe { Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params); }
            }
            
            public static 
            void GetObjectParameteriv(Int32 obj, GL.Enums.ARB_shader_objects pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetObjectParameteriv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetObjectParameteriv(Int32 obj, GL.Enums.ARB_shader_objects pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetObjectParameteriv(GLhandleARB obj, GL.Enums.ARB_shader_objects pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectParameterivARB((GLhandleARB)obj, (GL.Enums.ARB_shader_objects)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInfoLog(Int32 obj, GLsizei maxLength, GLsizei* length, System.Text.StringBuilder infoLog)
            {
                length = default(GLsizei*);
                infoLog = default(System.Text.StringBuilder);
                    {
                        Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length, (System.Text.StringBuilder)infoLog);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInfoLog(GLhandleARB obj, GLsizei maxLength, GLsizei* length, System.Text.StringBuilder infoLog)
            {
                unsafe { Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length, (System.Text.StringBuilder)infoLog); }
            }
            
            public static 
            void GetInfoLog(Int32 obj, GLsizei maxLength, GLsizei[] length, System.Text.StringBuilder infoLog)
            {
                infoLog = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetInfoLog(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, System.Text.StringBuilder infoLog)
            {
                infoLog = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                    }
                }
            }
            
            public static 
            void GetInfoLog(Int32 obj, GLsizei maxLength, out GLsizei length, System.Text.StringBuilder infoLog)
            {
                length = default(GLsizei);
                infoLog = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                        length = *length_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetInfoLog(GLhandleARB obj, GLsizei maxLength, out GLsizei length, System.Text.StringBuilder infoLog)
            {
                length = default(GLsizei);
                infoLog = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetInfoLogARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder)infoLog);
                        length = *length_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei* count, Int32* obj)
            {
                count = default(GLsizei*);
                obj = default(Int32*);
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj)
            {
                unsafe { Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei* count, Int32[] obj)
            {
                count = default(GLsizei*);
                    fixed (Int32* obj_ptr = obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB[] obj)
            {
                count = default(GLsizei*);
                    fixed (GLhandleARB* obj_ptr = obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei* count, out Int32 obj)
            {
                count = default(GLsizei*);
                obj = default(Int32);
                    fixed (Int32* obj_ptr = &obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj_ptr);
                        obj = *obj_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, out GLhandleARB obj)
            {
                count = default(GLsizei*);
                obj = default(GLhandleARB);
                    fixed (GLhandleARB* obj_ptr = &obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count, (GLhandleARB*)obj_ptr);
                        obj = *obj_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei[] count, Int32* obj)
            {
                obj = default(Int32*);
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB* obj)
            {
                obj = default(GLhandleARB*);
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj);
                    }
            }
            
            public static 
            void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei[] count, Int32[] obj)
            {
                unsafe
                {
                    fixed (GLsizei* count_ptr = count)
                    fixed (Int32* obj_ptr = obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB[] obj)
            {
                unsafe
                {
                    fixed (GLsizei* count_ptr = count)
                    fixed (GLhandleARB* obj_ptr = obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
                    }
                }
            }
            
            public static 
            void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, GLsizei[] count, out Int32 obj)
            {
                obj = default(Int32);
                unsafe
                {
                    fixed (GLsizei* count_ptr = count)
                    fixed (Int32* obj_ptr = &obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
                        obj = *obj_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, out GLhandleARB obj)
            {
                obj = default(GLhandleARB);
                unsafe
                {
                    fixed (GLsizei* count_ptr = count)
                    fixed (GLhandleARB* obj_ptr = &obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
                        obj = *obj_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, out GLsizei count, Int32* obj)
            {
                count = default(GLsizei);
                obj = default(Int32*);
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj);
                        count = *count_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, GLhandleARB* obj)
            {
                count = default(GLsizei);
                obj = default(GLhandleARB*);
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj);
                        count = *count_ptr;
                    }
            }
            
            public static 
            void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, out GLsizei count, Int32[] obj)
            {
                count = default(GLsizei);
                unsafe
                {
                    fixed (GLsizei* count_ptr = &count)
                    fixed (Int32* obj_ptr = obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
                        count = *count_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, GLhandleARB[] obj)
            {
                count = default(GLsizei);
                unsafe
                {
                    fixed (GLsizei* count_ptr = &count)
                    fixed (GLhandleARB* obj_ptr = obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
                        count = *count_ptr;
                    }
                }
            }
            
            public static 
            void GetAttachedObjects(Int32 containerObj, GLsizei maxCount, out GLsizei count, out Int32 obj)
            {
                count = default(GLsizei);
                obj = default(Int32);
                unsafe
                {
                    fixed (GLsizei* count_ptr = &count)
                    fixed (Int32* obj_ptr = &obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
                        count = *count_ptr;
                        obj = *obj_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetAttachedObjects(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, out GLhandleARB obj)
            {
                count = default(GLsizei);
                obj = default(GLhandleARB);
                unsafe
                {
                    fixed (GLsizei* count_ptr = &count)
                    fixed (GLhandleARB* obj_ptr = &obj)
                    {
                        Delegates.glGetAttachedObjectsARB((GLhandleARB)containerObj, (GLsizei)maxCount, (GLsizei*)count_ptr, (GLhandleARB*)obj_ptr);
                        count = *count_ptr;
                        obj = *obj_ptr;
                    }
                }
            }
            
            public static 
            GLint GetUniformLocation(Int32 programObj, System.String name)
            {
                return Delegates.glGetUniformLocationARB((GLhandleARB)programObj, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint GetUniformLocation(GLhandleARB programObj, System.String name)
            {
                return Delegates.glGetUniformLocationARB((GLhandleARB)programObj, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                unsafe { Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }
            
            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_shader_objects* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
            }
            
            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_shader_objects[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, out GL.Enums.ARB_shader_objects type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                type = default(GL.Enums.ARB_shader_objects);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_shader_objects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_shader_objects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniformfv(Int32 programObj, GLint location, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniformfv(GLhandleARB programObj, GLint location, GLfloat* @params)
            {
                unsafe { Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params); }
            }
            
            public static 
            void GetUniformfv(Int32 programObj, GLint location, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetUniformfv(GLhandleARB programObj, GLint location, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetUniformfv(Int32 programObj, GLint location, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetUniformfv(GLhandleARB programObj, GLint location, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformfvARB((GLhandleARB)programObj, (GLint)location, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniformiv(Int32 programObj, GLint location, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniformiv(GLhandleARB programObj, GLint location, GLint* @params)
            {
                unsafe { Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params); }
            }
            
            public static 
            void GetUniformiv(Int32 programObj, GLint location, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetUniformiv(GLhandleARB programObj, GLint location, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetUniformiv(Int32 programObj, GLint location, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetUniformiv(GLhandleARB programObj, GLint location, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformivARB((GLhandleARB)programObj, (GLint)location, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetShaderSource(Int32 obj, GLsizei maxLength, GLsizei* length, System.Text.StringBuilder[] source)
            {
                length = default(GLsizei*);
                source = default(System.Text.StringBuilder[]);
                    {
                        Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length, (System.Text.StringBuilder[])source);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetShaderSource(GLhandleARB obj, GLsizei maxLength, GLsizei* length, System.Text.StringBuilder[] source)
            {
                unsafe { Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length, (System.Text.StringBuilder[])source); }
            }
            
            public static 
            void GetShaderSource(Int32 obj, GLsizei maxLength, GLsizei[] length, System.Text.StringBuilder[] source)
            {
                source = default(System.Text.StringBuilder[]);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetShaderSource(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, System.Text.StringBuilder[] source)
            {
                source = default(System.Text.StringBuilder[]);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
                    }
                }
            }
            
            public static 
            void GetShaderSource(Int32 obj, GLsizei maxLength, out GLsizei length, System.Text.StringBuilder[] source)
            {
                length = default(GLsizei);
                source = default(System.Text.StringBuilder[]);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
                        length = *length_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetShaderSource(GLhandleARB obj, GLsizei maxLength, out GLsizei length, System.Text.StringBuilder[] source)
            {
                length = default(GLsizei);
                source = default(System.Text.StringBuilder[]);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetShaderSourceARB((GLhandleARB)obj, (GLsizei)maxLength, (GLsizei*)length_ptr, (System.Text.StringBuilder[])source);
                        length = *length_ptr;
                    }
                }
            }
            
            public static 
            void BindAttribLocation(Int32 programObj, Int32 index, System.String name)
            {
                Delegates.glBindAttribLocationARB((GLhandleARB)programObj, (GLuint)index, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindAttribLocation(GLhandleARB programObj, GLuint index, System.String name)
            {
                Delegates.glBindAttribLocationARB((GLhandleARB)programObj, (GLuint)index, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                unsafe { Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei* length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }
            
            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, GLsizei[] length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint* size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint*);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_vertex_shader* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
            }
            
            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, GL.Enums.ARB_vertex_shader[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, GLsizei maxLength, out GLsizei length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, out GL.Enums.ARB_vertex_shader type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLint);
                type = default(GL.Enums.ARB_vertex_shader);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLint* size_ptr = &size)
                    fixed (GL.Enums.ARB_vertex_shader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((GLhandleARB)programObj, (GLuint)index, (GLsizei)maxLength, (GLsizei*)length_ptr, (GLint*)size_ptr, (GL.Enums.ARB_vertex_shader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            public static 
            GLint GetAttribLocation(Int32 programObj, System.String name)
            {
                return Delegates.glGetAttribLocationARB((GLhandleARB)programObj, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint GetAttribLocation(GLhandleARB programObj, System.String name)
            {
                return Delegates.glGetAttribLocationARB((GLhandleARB)programObj, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DrawBuffers(GLsizei n, GL.Enums.ARB_draw_buffers* bufs)
            {
                unsafe { Delegates.glDrawBuffersARB((GLsizei)n, (GL.Enums.ARB_draw_buffers*)bufs); }
            }
            
            public static 
            void DrawBuffers(GLsizei n, GL.Enums.ARB_draw_buffers[] bufs)
            {
                unsafe
                {
                    fixed (GL.Enums.ARB_draw_buffers* bufs_ptr = bufs)
                    {
                        Delegates.glDrawBuffersARB((GLsizei)n, (GL.Enums.ARB_draw_buffers*)bufs_ptr);
                    }
                }
            }
            
            public static 
            void DrawBuffers(GLsizei n, ref GL.Enums.ARB_draw_buffers bufs)
            {
                unsafe
                {
                    fixed (GL.Enums.ARB_draw_buffers* bufs_ptr = &bufs)
                    {
                        Delegates.glDrawBuffersARB((GLsizei)n, (GL.Enums.ARB_draw_buffers*)bufs_ptr);
                    }
                }
            }
            
            public static 
            void ClampColor(GL.Enums.ARB_color_buffer_float target, GL.Enums.ARB_color_buffer_float clamp)
            {
                Delegates.glClampColorARB((GL.Enums.ARB_color_buffer_float)target, (GL.Enums.ARB_color_buffer_float)clamp);
            }
            
        }

        public static class EXT
        {
            public static 
            void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
            {
                Delegates.glBlendColorEXT((GLclampf)red, (GLclampf)green, (GLclampf)blue, (GLclampf)alpha);
            }
            
            public static 
            void PolygonOffset(GLfloat factor, GLfloat bias)
            {
                Delegates.glPolygonOffsetEXT((GLfloat)factor, (GLfloat)bias);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
            {
                unsafe { Delegates.glTexImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
            }
            
            public static 
            void TexImage3D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTexImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pixels_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
            {
                unsafe { Delegates.glTexSubImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
            }
            
            public static 
            void TexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTexSubImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pixels_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
            {
                unsafe { Delegates.glTexSubImage1DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
            }
            
            public static 
            void TexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTexSubImage1DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pixels_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
            {
                unsafe { Delegates.glTexSubImage2DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
            }
            
            public static 
            void TexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTexSubImage2DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pixels_ptr.Free();
                    }
                }
            }
            
            public static 
            void CopyTexImage1D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border)
            {
                Delegates.glCopyTexImage1DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLint)border);
            }
            
            public static 
            void CopyTexImage2D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
            {
                Delegates.glCopyTexImage2DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height, (GLint)border);
            }
            
            public static 
            void CopyTexSubImage1D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
            {
                Delegates.glCopyTexSubImage1DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)x, (GLint)y, (GLsizei)width);
            }
            
            public static 
            void CopyTexSubImage2D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
            {
                Delegates.glCopyTexSubImage2DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
            }
            
            public static 
            void CopyTexSubImage3D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
            {
                Delegates.glCopyTexSubImage3DEXT((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetHistogram(GL.Enums.HistogramTargetEXT target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* values)
            {
                unsafe { Delegates.glGetHistogramEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.Boolean)reset, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)values); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetHistogramParameterfv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetHistogramParameterfv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetHistogramParameterfv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetHistogramParameterfvEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetHistogramParameteriv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, GLint* @params)
            {
                unsafe { Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLint*)@params); }
            }
            
            public static 
            void GetHistogramParameteriv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetHistogramParameteriv(GL.Enums.HistogramTargetEXT target, GL.Enums.GetHistogramParameterPNameEXT pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetHistogramParameterivEXT((GL.Enums.HistogramTargetEXT)target, (GL.Enums.GetHistogramParameterPNameEXT)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMinmax(GL.Enums.MinmaxTargetEXT target, GL.Enums.Boolean reset, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* values)
            {
                unsafe { Delegates.glGetMinmaxEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.Boolean)reset, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)values); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMinmaxParameterfv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetMinmaxParameterfv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetMinmaxParameterfv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetMinmaxParameterfvEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMinmaxParameteriv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, GLint* @params)
            {
                unsafe { Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLint*)@params); }
            }
            
            public static 
            void GetMinmaxParameteriv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetMinmaxParameteriv(GL.Enums.MinmaxTargetEXT target, GL.Enums.GetMinmaxParameterPNameEXT pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetMinmaxParameterivEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.GetMinmaxParameterPNameEXT)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void Histogram(GL.Enums.HistogramTargetEXT target, GLsizei width, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
            {
                 Delegates.glHistogramEXT((GL.Enums.HistogramTargetEXT)target, (GLsizei)width, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink); 
            }
            
            public static 
            void Minmax(GL.Enums.MinmaxTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GL.Enums.Boolean sink)
            {
                 Delegates.glMinmaxEXT((GL.Enums.MinmaxTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GL.Enums.Boolean)sink); 
            }
            
            public static 
            void ResetHistogram(GL.Enums.HistogramTargetEXT target)
            {
                Delegates.glResetHistogramEXT((GL.Enums.HistogramTargetEXT)target);
            }
            
            public static 
            void ResetMinmax(GL.Enums.MinmaxTargetEXT target)
            {
                Delegates.glResetMinmaxEXT((GL.Enums.MinmaxTargetEXT)target);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ConvolutionFilter1D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
            {
                unsafe { Delegates.glConvolutionFilter1DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
            }
            
            public static 
            void ConvolutionFilter1D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glConvolutionFilter1DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        image_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ConvolutionFilter2D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
            {
                unsafe { Delegates.glConvolutionFilter2DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
            }
            
            public static 
            void ConvolutionFilter2D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glConvolutionFilter2DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        image_ptr.Free();
                    }
                }
            }
            
            public static 
            void ConvolutionParameterf(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat @params)
            {
                Delegates.glConvolutionParameterfEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat)@params);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat* @params)
            {
                unsafe { Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params); }
            }
            
            public static 
            void ConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ConvolutionParameteri(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint @params)
            {
                Delegates.glConvolutionParameteriEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint)@params);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint* @params)
            {
                unsafe { Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params); }
            }
            
            public static 
            void ConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CopyConvolutionFilter1D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
            {
                Delegates.glCopyConvolutionFilter1DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width);
            }
            
            public static 
            void CopyConvolutionFilter2D(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
            {
                Delegates.glCopyConvolutionFilter2DEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetConvolutionFilter(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* image)
            {
                unsafe { Delegates.glGetConvolutionFilterEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image); }
            }
            
            public static 
            void GetConvolutionFilter(GL.Enums.ConvolutionTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object image)
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetConvolutionFilterEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)image_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        image_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetConvolutionParameterfv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetConvolutionParameterfvEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint* @params)
            {
                unsafe { Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params); }
            }
            
            public static 
            void GetConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetConvolutionParameteriv(GL.Enums.ConvolutionTargetEXT target, GL.Enums.ConvolutionParameterEXT pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetConvolutionParameterivEXT((GL.Enums.ConvolutionTargetEXT)target, (GL.Enums.ConvolutionParameterEXT)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column, void* span)
            {
                unsafe { Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column, (void*)span); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column, object span)
            {
                row = default(void*);
                column = default(void*);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column, (void*)span_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        span_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column, void* span)
            {
                row = default(void*);
                span = default(void*);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject(), (void*)span);
                    }
                    finally
                    {
                        column_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column, object span)
            {
                row = default(void*);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, 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((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject(), (void*)span_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        column_ptr.Free();
                        span_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column, void* span)
            {
                column = default(void*);
                span = default(void*);
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column, (void*)span);
                    }
                    finally
                    {
                        row_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column, object span)
            {
                column = default(void*);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column, (void*)span_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        row_ptr.Free();
                        span_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column, void* span)
            {
                span = default(void*);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject(), (void*)span);
                    }
                    finally
                    {
                        row_ptr.Free();
                        column_ptr.Free();
                    }
            }
            
            public static 
            void GetSeparableFilter(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column, object span)
            {
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, 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 row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetSeparableFilterEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject(), (void*)span_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        row_ptr.Free();
                        column_ptr.Free();
                        span_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SeparableFilter2D(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, void* column)
            {
                unsafe { Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SeparableFilter2D(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* row, object column)
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row, (void*)column_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        column_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SeparableFilter2D(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, void* column)
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column);
                    }
                    finally
                    {
                        row_ptr.Free();
                    }
            }
            
            public static 
            void SeparableFilter2D(GL.Enums.SeparableTargetEXT target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object row, object column)
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glSeparableFilter2DEXT((GL.Enums.SeparableTargetEXT)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)row_ptr.AddrOfPinnedObject(), (void*)column_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        row_ptr.Free();
                        column_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreTexturesResident(GLsizei n, Int32* textures, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    {
                        GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreTexturesResident(GLsizei n, GLuint* textures, GL.Enums.Boolean* residences)
            {
                unsafe { return Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures, (GL.Enums.Boolean*)residences); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreTexturesResident(GLsizei n, Int32[] textures, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    fixed (Int32* textures_ptr = textures)
                    {
                        GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    fixed (GLuint* textures_ptr = textures)
                    {
                        GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreTexturesResident(GLsizei n, ref Int32 textures, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    fixed (Int32* textures_ptr = &textures)
                    {
                        GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreTexturesResident(GLsizei n, ref GLuint textures, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    fixed (GLuint* textures_ptr = &textures)
                    {
                        GLboolean retval = Delegates.glAreTexturesResidentEXT((GLsizei)n, (GLuint*)textures_ptr, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            public static 
            void BindTexture(GL.Enums.TextureTarget target, Int32 texture)
            {
                Delegates.glBindTextureEXT((GL.Enums.TextureTarget)target, (GLuint)texture);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindTexture(GL.Enums.TextureTarget target, GLuint texture)
            {
                Delegates.glBindTextureEXT((GL.Enums.TextureTarget)target, (GLuint)texture);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteTextures(GLsizei n, Int32* textures)
            {
                    {
                        Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteTextures(GLsizei n, GLuint* textures)
            {
                unsafe { Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures); }
            }
            
            public static 
            void DeleteTextures(GLsizei n, Int32[] textures)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = textures)
                    {
                        Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteTextures(GLsizei n, GLuint[] textures)
            {
                unsafe
                {
                    fixed (GLuint* textures_ptr = textures)
                    {
                        Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
                    }
                }
            }
            
            public static 
            void DeleteTextures(GLsizei n, ref Int32 textures)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = &textures)
                    {
                        Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteTextures(GLsizei n, ref GLuint textures)
            {
                unsafe
                {
                    fixed (GLuint* textures_ptr = &textures)
                    {
                        Delegates.glDeleteTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenTextures(GLsizei n, Int32* textures)
            {
                textures = default(Int32*);
                    {
                        Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenTextures(GLsizei n, GLuint* textures)
            {
                unsafe { Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures); }
            }
            
            public static 
            void GenTextures(GLsizei n, Int32[] textures)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = textures)
                    {
                        Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenTextures(GLsizei n, GLuint[] textures)
            {
                unsafe
                {
                    fixed (GLuint* textures_ptr = textures)
                    {
                        Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
                    }
                }
            }
            
            public static 
            void GenTextures(GLsizei n, out Int32 textures)
            {
                textures = default(Int32);
                unsafe
                {
                    fixed (Int32* textures_ptr = &textures)
                    {
                        Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
                        textures = *textures_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenTextures(GLsizei n, out GLuint textures)
            {
                textures = default(GLuint);
                unsafe
                {
                    fixed (GLuint* textures_ptr = &textures)
                    {
                        Delegates.glGenTexturesEXT((GLsizei)n, (GLuint*)textures_ptr);
                        textures = *textures_ptr;
                    }
                }
            }
            
            public static 
            GLboolean IsTexture(Int32 texture)
            {
                return Delegates.glIsTextureEXT((GLuint)texture);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsTexture(GLuint texture)
            {
                return Delegates.glIsTextureEXT((GLuint)texture);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, Int32* textures, GLclampf* priorities)
            {
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, GLclampf* priorities)
            {
                unsafe { Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, Int32* textures, GLclampf[] priorities)
            {
                    fixed (GLclampf* priorities_ptr = priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, GLclampf[] priorities)
            {
                    fixed (GLclampf* priorities_ptr = priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, Int32* textures, ref GLclampf priorities)
            {
                    fixed (GLclampf* priorities_ptr = &priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, GLuint* textures, ref GLclampf priorities)
            {
                    fixed (GLclampf* priorities_ptr = &priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures, (GLclampf*)priorities_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, Int32[] textures, GLclampf* priorities)
            {
                    fixed (Int32* textures_ptr = textures)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf* priorities)
            {
                    fixed (GLuint* textures_ptr = textures)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
                    }
            }
            
            public static 
            void PrioritizeTextures(GLsizei n, Int32[] textures, GLclampf[] priorities)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = textures)
                    fixed (GLclampf* priorities_ptr = priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf[] priorities)
            {
                unsafe
                {
                    fixed (GLuint* textures_ptr = textures)
                    fixed (GLclampf* priorities_ptr = priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                    }
                }
            }
            
            public static 
            void PrioritizeTextures(GLsizei n, Int32[] textures, ref GLclampf priorities)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = textures)
                    fixed (GLclampf* priorities_ptr = &priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void PrioritizeTextures(GLsizei n, GLuint[] textures, ref GLclampf priorities)
            {
                unsafe
                {
                    fixed (GLuint* textures_ptr = textures)
                    fixed (GLclampf* priorities_ptr = &priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, ref Int32 textures, GLclampf* priorities)
            {
                    fixed (Int32* textures_ptr = &textures)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf* priorities)
            {
                    fixed (GLuint* textures_ptr = &textures)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities);
                    }
            }
            
            public static 
            void PrioritizeTextures(GLsizei n, ref Int32 textures, GLclampf[] priorities)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = &textures)
                    fixed (GLclampf* priorities_ptr = priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf[] priorities)
            {
                unsafe
                {
                    fixed (GLuint* textures_ptr = &textures)
                    fixed (GLclampf* priorities_ptr = priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                    }
                }
            }
            
            public static 
            void PrioritizeTextures(GLsizei n, ref Int32 textures, ref GLclampf priorities)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = &textures)
                    fixed (GLclampf* priorities_ptr = &priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void PrioritizeTextures(GLsizei n, ref GLuint textures, ref GLclampf priorities)
            {
                unsafe
                {
                    fixed (GLuint* textures_ptr = &textures)
                    fixed (GLclampf* priorities_ptr = &priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((GLsizei)n, (GLuint*)textures_ptr, (GLclampf*)priorities_ptr);
                    }
                }
            }
            
            public static 
            void ArrayElement(GLint i)
            {
                Delegates.glArrayElementEXT((GLint)i);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, GLsizei count, void* pointer)
            {
                unsafe { Delegates.glColorPointerEXT((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
            }
            
            public static 
            void ColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, GLsizei count, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glColorPointerEXT((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void DrawArrays(GL.Enums.BeginMode mode, GLint first, GLsizei count)
            {
                Delegates.glDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint)first, (GLsizei)count);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void EdgeFlagPointer(GLsizei stride, GLsizei count, GL.Enums.Boolean* pointer)
            {
                unsafe { Delegates.glEdgeFlagPointerEXT((GLsizei)stride, (GLsizei)count, (GL.Enums.Boolean*)pointer); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetPointerv(GL.Enums.GetPointervPName pname, void* @params)
            {
                unsafe { Delegates.glGetPointervEXT((GL.Enums.GetPointervPName)pname, (void*)@params); }
            }
            
            public static 
            void GetPointerv(GL.Enums.GetPointervPName pname, object @params)
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetPointervEXT((GL.Enums.GetPointervPName)pname, (void*)@params_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        @params_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void IndexPointer(GL.Enums.IndexPointerType type, GLsizei stride, GLsizei count, void* pointer)
            {
                unsafe { Delegates.glIndexPointerEXT((GL.Enums.IndexPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
            }
            
            public static 
            void IndexPointer(GL.Enums.IndexPointerType type, GLsizei stride, GLsizei count, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glIndexPointerEXT((GL.Enums.IndexPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalPointer(GL.Enums.NormalPointerType type, GLsizei stride, GLsizei count, void* pointer)
            {
                unsafe { Delegates.glNormalPointerEXT((GL.Enums.NormalPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
            }
            
            public static 
            void NormalPointer(GL.Enums.NormalPointerType type, GLsizei stride, GLsizei count, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glNormalPointerEXT((GL.Enums.NormalPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoordPointer(GLint size, GL.Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, void* pointer)
            {
                unsafe { Delegates.glTexCoordPointerEXT((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
            }
            
            public static 
            void TexCoordPointer(GLint size, GL.Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTexCoordPointerEXT((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexPointer(GLint size, GL.Enums.VertexPointerType type, GLsizei stride, GLsizei count, void* pointer)
            {
                unsafe { Delegates.glVertexPointerEXT((GLint)size, (GL.Enums.VertexPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer); }
            }
            
            public static 
            void VertexPointer(GLint size, GL.Enums.VertexPointerType type, GLsizei stride, GLsizei count, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexPointerEXT((GLint)size, (GL.Enums.VertexPointerType)type, (GLsizei)stride, (GLsizei)count, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void BlendEquation(GL.Enums.BlendEquationModeEXT mode)
            {
                Delegates.glBlendEquationEXT((GL.Enums.BlendEquationModeEXT)mode);
            }
            
            public static 
            void PointParameterf(GL.Enums.EXT_point_parameters pname, GLfloat param)
            {
                Delegates.glPointParameterfEXT((GL.Enums.EXT_point_parameters)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PointParameterfv(GL.Enums.EXT_point_parameters pname, GLfloat* @params)
            {
                unsafe { Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (GLfloat*)@params); }
            }
            
            public static 
            void PointParameterfv(GL.Enums.EXT_point_parameters pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PointParameterfv(GL.Enums.EXT_point_parameters pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glPointParameterfvEXT((GL.Enums.EXT_point_parameters)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorSubTable(GL.Enums.EXT_color_subtable target, GLsizei start, GLsizei count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* data)
            {
                unsafe { Delegates.glColorSubTableEXT((GL.Enums.EXT_color_subtable)target, (GLsizei)start, (GLsizei)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
            }
            
            public static 
            void ColorSubTable(GL.Enums.EXT_color_subtable target, GLsizei start, GLsizei count, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glColorSubTableEXT((GL.Enums.EXT_color_subtable)target, (GLsizei)start, (GLsizei)count, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            public static 
            void CopyColorSubTable(GL.Enums.EXT_color_subtable target, GLsizei start, GLint x, GLint y, GLsizei width)
            {
                Delegates.glCopyColorSubTableEXT((GL.Enums.EXT_color_subtable)target, (GLsizei)start, (GLint)x, (GLint)y, (GLsizei)width);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorTable(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelInternalFormat internalFormat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
            {
                unsafe { Delegates.glColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelInternalFormat)internalFormat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
            }
            
            public static 
            void ColorTable(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelInternalFormat internalFormat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelInternalFormat)internalFormat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        table_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTable(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* data)
            {
                unsafe { Delegates.glGetColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data); }
            }
            
            public static 
            void GetColorTable(GL.Enums.EXT_paletted_texture target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetColorTableEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTableParameteriv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, GLint* @params)
            {
                unsafe { Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLint*)@params); }
            }
            
            public static 
            void GetColorTableParameteriv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetColorTableParameteriv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetColorTableParameterivEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTableParameterfv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetColorTableParameterfv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetColorTableParameterfv(GL.Enums.EXT_paletted_texture target, GL.Enums.EXT_paletted_texture pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetColorTableParameterfvEXT((GL.Enums.EXT_paletted_texture)target, (GL.Enums.EXT_paletted_texture)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void IndexMaterial(GL.Enums.MaterialFace face, GL.Enums.EXT_index_material mode)
            {
                Delegates.glIndexMaterialEXT((GL.Enums.MaterialFace)face, (GL.Enums.EXT_index_material)mode);
            }
            
            public static 
            void IndexFunc(GL.Enums.EXT_index_func func, GLclampf @ref)
            {
                Delegates.glIndexFuncEXT((GL.Enums.EXT_index_func)func, (GLclampf)@ref);
            }
            
            public static 
            void LockArrays(GLint first, GLsizei count)
            {
                Delegates.glLockArraysEXT((GLint)first, (GLsizei)count);
            }
            
            public static 
            void UnlockArrays()
            {
                Delegates.glUnlockArraysEXT();
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CullParameterdv(GL.Enums.EXT_cull_vertex pname, GLdouble* @params)
            {
                unsafe { Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (GLdouble*)@params); }
            }
            
            public static 
            void CullParameterdv(GL.Enums.EXT_cull_vertex pname, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CullParameterdv(GL.Enums.EXT_cull_vertex pname, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glCullParameterdvEXT((GL.Enums.EXT_cull_vertex)pname, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CullParameterfv(GL.Enums.EXT_cull_vertex pname, GLfloat* @params)
            {
                unsafe { Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (GLfloat*)@params); }
            }
            
            public static 
            void CullParameterfv(GL.Enums.EXT_cull_vertex pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CullParameterfv(GL.Enums.EXT_cull_vertex pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glCullParameterfvEXT((GL.Enums.EXT_cull_vertex)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count, GL.Enums.EXT_draw_range_elements type, void* indices)
            {
                    {
                        Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DrawRangeElements(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GL.Enums.EXT_draw_range_elements type, void* indices)
            {
                unsafe { Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices); }
            }
            
            public static 
            void DrawRangeElements(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count, GL.Enums.EXT_draw_range_elements type, object indices)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DrawRangeElements(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GL.Enums.EXT_draw_range_elements type, object indices)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glDrawRangeElementsEXT((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count, (GL.Enums.EXT_draw_range_elements)type, (void*)indices_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            public static 
            void ApplyTexture(GL.Enums.EXT_light_texture mode)
            {
                Delegates.glApplyTextureEXT((GL.Enums.EXT_light_texture)mode);
            }
            
            public static 
            void TextureLight(GL.Enums.EXT_light_texture pname)
            {
                Delegates.glTextureLightEXT((GL.Enums.EXT_light_texture)pname);
            }
            
            public static 
            void TextureMaterial(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter mode)
            {
                Delegates.glTextureMaterialEXT((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)mode);
            }
            
            public static 
            void PixelTransformParameteri(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLint param)
            {
                Delegates.glPixelTransformParameteriEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLint)param);
            }
            
            public static 
            void PixelTransformParameterf(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLfloat param)
            {
                Delegates.glPixelTransformParameterfEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelTransformParameteriv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLint* @params)
            {
                unsafe { Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLint*)@params); }
            }
            
            public static 
            void PixelTransformParameteriv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PixelTransformParameteriv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glPixelTransformParameterivEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelTransformParameterfv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLfloat* @params)
            {
                unsafe { Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLfloat*)@params); }
            }
            
            public static 
            void PixelTransformParameterfv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PixelTransformParameterfv(GL.Enums.EXT_pixel_transform target, GL.Enums.EXT_pixel_transform pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glPixelTransformParameterfvEXT((GL.Enums.EXT_pixel_transform)target, (GL.Enums.EXT_pixel_transform)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3b(Byte red, Byte green, Byte blue)
            {
                Delegates.glSecondaryColor3bEXT((GLbyte)red, (GLbyte)green, (GLbyte)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
            {
                Delegates.glSecondaryColor3bEXT((GLbyte)red, (GLbyte)green, (GLbyte)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3bv(Byte* v)
            {
                    {
                        Delegates.glSecondaryColor3bvEXT((GLbyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3bv(GLbyte* v)
            {
                unsafe { Delegates.glSecondaryColor3bvEXT((GLbyte*)v); }
            }
            
            public static 
            void SecondaryColor3bv(Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3bv(GLbyte[] v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3bv(ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3bv(ref GLbyte v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
            {
                Delegates.glSecondaryColor3dEXT((GLdouble)red, (GLdouble)green, (GLdouble)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3dv(GLdouble* v)
            {
                unsafe { Delegates.glSecondaryColor3dvEXT((GLdouble*)v); }
            }
            
            public static 
            void SecondaryColor3dv(GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3dvEXT((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3dv(ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3dvEXT((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
            {
                Delegates.glSecondaryColor3fEXT((GLfloat)red, (GLfloat)green, (GLfloat)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3fv(GLfloat* v)
            {
                unsafe { Delegates.glSecondaryColor3fvEXT((GLfloat*)v); }
            }
            
            public static 
            void SecondaryColor3fv(GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3fvEXT((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3fv(ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3fvEXT((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3i(GLint red, GLint green, GLint blue)
            {
                Delegates.glSecondaryColor3iEXT((GLint)red, (GLint)green, (GLint)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3iv(GLint* v)
            {
                unsafe { Delegates.glSecondaryColor3ivEXT((GLint*)v); }
            }
            
            public static 
            void SecondaryColor3iv(GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3ivEXT((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3iv(ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3ivEXT((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
            {
                Delegates.glSecondaryColor3sEXT((GLshort)red, (GLshort)green, (GLshort)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3sv(GLshort* v)
            {
                unsafe { Delegates.glSecondaryColor3svEXT((GLshort*)v); }
            }
            
            public static 
            void SecondaryColor3sv(GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3svEXT((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3sv(ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3svEXT((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
            {
                Delegates.glSecondaryColor3ubEXT((GLubyte)red, (GLubyte)green, (GLubyte)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3ubv(GLubyte* v)
            {
                unsafe { Delegates.glSecondaryColor3ubvEXT((GLubyte*)v); }
            }
            
            public static 
            void SecondaryColor3ubv(GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3ubvEXT((GLubyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3ubv(ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3ubvEXT((GLubyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3ui(Int32 red, Int32 green, Int32 blue)
            {
                Delegates.glSecondaryColor3uiEXT((GLuint)red, (GLuint)green, (GLuint)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
            {
                Delegates.glSecondaryColor3uiEXT((GLuint)red, (GLuint)green, (GLuint)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3uiv(Int32* v)
            {
                    {
                        Delegates.glSecondaryColor3uivEXT((GLuint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3uiv(GLuint* v)
            {
                unsafe { Delegates.glSecondaryColor3uivEXT((GLuint*)v); }
            }
            
            public static 
            void SecondaryColor3uiv(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3uivEXT((GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3uiv(GLuint[] v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3uivEXT((GLuint*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3uiv(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3uivEXT((GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3uiv(ref GLuint v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3uivEXT((GLuint*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3us(Int16 red, Int16 green, Int16 blue)
            {
                Delegates.glSecondaryColor3usEXT((GLushort)red, (GLushort)green, (GLushort)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3us(GLushort red, GLushort green, GLushort blue)
            {
                Delegates.glSecondaryColor3usEXT((GLushort)red, (GLushort)green, (GLushort)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3usv(Int16* v)
            {
                    {
                        Delegates.glSecondaryColor3usvEXT((GLushort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3usv(GLushort* v)
            {
                unsafe { Delegates.glSecondaryColor3usvEXT((GLushort*)v); }
            }
            
            public static 
            void SecondaryColor3usv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3usvEXT((GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3usv(GLushort[] v)
            {
                unsafe
                {
                    fixed (GLushort* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3usvEXT((GLushort*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3usv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3usvEXT((GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3usv(ref GLushort v)
            {
                unsafe
                {
                    fixed (GLushort* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3usvEXT((GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glSecondaryColorPointerEXT((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void SecondaryColorPointer(GLint size, GL.Enums.ColorPointerType type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glSecondaryColorPointerEXT((GLint)size, (GL.Enums.ColorPointerType)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void TextureNormal(GL.Enums.EXT_texture_perturb_normal mode)
            {
                Delegates.glTextureNormalEXT((GL.Enums.EXT_texture_perturb_normal)mode);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, GLsizei* count, GLsizei primcount)
            {
                unsafe { Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count, (GLsizei)primcount); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, GLsizei[] count, GLsizei primcount)
            {
                first = default(GLint*);
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint* first, out GLsizei count, GLsizei primcount)
            {
                first = default(GLint*);
                count = default(GLsizei);
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                        count = *count_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, GLsizei* count, GLsizei primcount)
            {
                count = default(GLsizei*);
                    fixed (GLint* first_ptr = first)
                    {
                        Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                    }
            }
            
            public static 
            void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            public static 
            void MultiDrawArrays(GL.Enums.BeginMode mode, GLint[] first, out GLsizei count, GLsizei primcount)
            {
                count = default(GLsizei);
                unsafe
                {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                        count = *count_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, GLsizei* count, GLsizei primcount)
            {
                first = default(GLint);
                count = default(GLsizei*);
                    fixed (GLint* first_ptr = &first)
                    {
                        Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                        first = *first_ptr;
                    }
            }
            
            public static 
            void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, GLsizei[] count, GLsizei primcount)
            {
                first = default(GLint);
                unsafe
                {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                        first = *first_ptr;
                    }
                }
            }
            
            public static 
            void MultiDrawArrays(GL.Enums.BeginMode mode, out GLint first, out GLsizei count, GLsizei primcount)
            {
                first = default(GLint);
                count = default(GLsizei);
                unsafe
                {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawArraysEXT((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                        first = *first_ptr;
                        count = *count_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.EXT_multi_draw_arrays type, void* indices, GLsizei primcount)
            {
                unsafe { Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (GLsizei)primcount); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.EXT_multi_draw_arrays type, object indices, GLsizei primcount)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.EXT_multi_draw_arrays type, void* indices, GLsizei primcount)
            {
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (GLsizei)primcount);
                    }
            }
            
            public static 
            void MultiDrawElements(GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.EXT_multi_draw_arrays type, object indices, GLsizei primcount)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    fixed (GLsizei* count_ptr = count)
                    try
                    {
                        Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElements(GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.EXT_multi_draw_arrays type, void* indices, GLsizei primcount)
            {
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices, (GLsizei)primcount);
                    }
            }
            
            public static 
            void MultiDrawElements(GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.EXT_multi_draw_arrays type, object indices, GLsizei primcount)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    fixed (GLsizei* count_ptr = &count)
                    try
                    {
                        Delegates.glMultiDrawElementsEXT((GL.Enums.BeginMode)mode, (GLsizei*)count_ptr, (GL.Enums.EXT_multi_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            public static 
            void FogCoordf(GLfloat coord)
            {
                Delegates.glFogCoordfEXT((GLfloat)coord);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordfv(GLfloat* coord)
            {
                unsafe { Delegates.glFogCoordfvEXT((GLfloat*)coord); }
            }
            
            public static 
            void FogCoordfv(GLfloat[] coord)
            {
                unsafe
                {
                    fixed (GLfloat* coord_ptr = coord)
                    {
                        Delegates.glFogCoordfvEXT((GLfloat*)coord_ptr);
                    }
                }
            }
            
            public static 
            void FogCoordfv(ref GLfloat coord)
            {
                unsafe
                {
                    fixed (GLfloat* coord_ptr = &coord)
                    {
                        Delegates.glFogCoordfvEXT((GLfloat*)coord_ptr);
                    }
                }
            }
            
            public static 
            void FogCoordd(GLdouble coord)
            {
                Delegates.glFogCoorddEXT((GLdouble)coord);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoorddv(GLdouble* coord)
            {
                unsafe { Delegates.glFogCoorddvEXT((GLdouble*)coord); }
            }
            
            public static 
            void FogCoorddv(GLdouble[] coord)
            {
                unsafe
                {
                    fixed (GLdouble* coord_ptr = coord)
                    {
                        Delegates.glFogCoorddvEXT((GLdouble*)coord_ptr);
                    }
                }
            }
            
            public static 
            void FogCoorddv(ref GLdouble coord)
            {
                unsafe
                {
                    fixed (GLdouble* coord_ptr = &coord)
                    {
                        Delegates.glFogCoorddvEXT((GLdouble*)coord_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordPointer(GL.Enums.EXT_fog_coord type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glFogCoordPointerEXT((GL.Enums.EXT_fog_coord)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void FogCoordPointer(GL.Enums.EXT_fog_coord type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glFogCoordPointerEXT((GL.Enums.EXT_fog_coord)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void Tangent3b(Byte tx, Byte ty, Byte tz)
            {
                Delegates.glTangent3bEXT((GLbyte)tx, (GLbyte)ty, (GLbyte)tz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Tangent3b(GLbyte tx, GLbyte ty, GLbyte tz)
            {
                Delegates.glTangent3bEXT((GLbyte)tx, (GLbyte)ty, (GLbyte)tz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3bv(Byte* v)
            {
                    {
                        Delegates.glTangent3bvEXT((GLbyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3bv(GLbyte* v)
            {
                unsafe { Delegates.glTangent3bvEXT((GLbyte*)v); }
            }
            
            public static 
            void Tangent3bv(Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glTangent3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Tangent3bv(GLbyte[] v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = v)
                    {
                        Delegates.glTangent3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3bv(ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glTangent3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Tangent3bv(ref GLbyte v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = &v)
                    {
                        Delegates.glTangent3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3d(GLdouble tx, GLdouble ty, GLdouble tz)
            {
                Delegates.glTangent3dEXT((GLdouble)tx, (GLdouble)ty, (GLdouble)tz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3dv(GLdouble* v)
            {
                unsafe { Delegates.glTangent3dvEXT((GLdouble*)v); }
            }
            
            public static 
            void Tangent3dv(GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glTangent3dvEXT((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3dv(ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glTangent3dvEXT((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3f(GLfloat tx, GLfloat ty, GLfloat tz)
            {
                Delegates.glTangent3fEXT((GLfloat)tx, (GLfloat)ty, (GLfloat)tz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3fv(GLfloat* v)
            {
                unsafe { Delegates.glTangent3fvEXT((GLfloat*)v); }
            }
            
            public static 
            void Tangent3fv(GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTangent3fvEXT((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3fv(ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTangent3fvEXT((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3i(GLint tx, GLint ty, GLint tz)
            {
                Delegates.glTangent3iEXT((GLint)tx, (GLint)ty, (GLint)tz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3iv(GLint* v)
            {
                unsafe { Delegates.glTangent3ivEXT((GLint*)v); }
            }
            
            public static 
            void Tangent3iv(GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glTangent3ivEXT((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3iv(ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glTangent3ivEXT((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3s(GLshort tx, GLshort ty, GLshort tz)
            {
                Delegates.glTangent3sEXT((GLshort)tx, (GLshort)ty, (GLshort)tz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3sv(GLshort* v)
            {
                unsafe { Delegates.glTangent3svEXT((GLshort*)v); }
            }
            
            public static 
            void Tangent3sv(GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glTangent3svEXT((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void Tangent3sv(ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glTangent3svEXT((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3b(Byte bx, Byte by, Byte bz)
            {
                Delegates.glBinormal3bEXT((GLbyte)bx, (GLbyte)by, (GLbyte)bz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Binormal3b(GLbyte bx, GLbyte by, GLbyte bz)
            {
                Delegates.glBinormal3bEXT((GLbyte)bx, (GLbyte)by, (GLbyte)bz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3bv(Byte* v)
            {
                    {
                        Delegates.glBinormal3bvEXT((GLbyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3bv(GLbyte* v)
            {
                unsafe { Delegates.glBinormal3bvEXT((GLbyte*)v); }
            }
            
            public static 
            void Binormal3bv(Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glBinormal3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Binormal3bv(GLbyte[] v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = v)
                    {
                        Delegates.glBinormal3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3bv(ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glBinormal3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Binormal3bv(ref GLbyte v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = &v)
                    {
                        Delegates.glBinormal3bvEXT((GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3d(GLdouble bx, GLdouble by, GLdouble bz)
            {
                Delegates.glBinormal3dEXT((GLdouble)bx, (GLdouble)by, (GLdouble)bz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3dv(GLdouble* v)
            {
                unsafe { Delegates.glBinormal3dvEXT((GLdouble*)v); }
            }
            
            public static 
            void Binormal3dv(GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glBinormal3dvEXT((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3dv(ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glBinormal3dvEXT((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3f(GLfloat bx, GLfloat by, GLfloat bz)
            {
                Delegates.glBinormal3fEXT((GLfloat)bx, (GLfloat)by, (GLfloat)bz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3fv(GLfloat* v)
            {
                unsafe { Delegates.glBinormal3fvEXT((GLfloat*)v); }
            }
            
            public static 
            void Binormal3fv(GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glBinormal3fvEXT((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3fv(ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glBinormal3fvEXT((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3i(GLint bx, GLint by, GLint bz)
            {
                Delegates.glBinormal3iEXT((GLint)bx, (GLint)by, (GLint)bz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3iv(GLint* v)
            {
                unsafe { Delegates.glBinormal3ivEXT((GLint*)v); }
            }
            
            public static 
            void Binormal3iv(GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glBinormal3ivEXT((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3iv(ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glBinormal3ivEXT((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3s(GLshort bx, GLshort by, GLshort bz)
            {
                Delegates.glBinormal3sEXT((GLshort)bx, (GLshort)by, (GLshort)bz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3sv(GLshort* v)
            {
                unsafe { Delegates.glBinormal3svEXT((GLshort*)v); }
            }
            
            public static 
            void Binormal3sv(GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glBinormal3svEXT((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void Binormal3sv(ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glBinormal3svEXT((GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TangentPointer(GL.Enums.EXT_coordinate_frame type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glTangentPointerEXT((GL.Enums.EXT_coordinate_frame)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void TangentPointer(GL.Enums.EXT_coordinate_frame type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTangentPointerEXT((GL.Enums.EXT_coordinate_frame)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void BinormalPointer(GL.Enums.EXT_coordinate_frame type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glBinormalPointerEXT((GL.Enums.EXT_coordinate_frame)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void BinormalPointer(GL.Enums.EXT_coordinate_frame type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glBinormalPointerEXT((GL.Enums.EXT_coordinate_frame)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void BlendFuncSeparate(GL.Enums.EXT_blend_func_separate sfactorRGB, GL.Enums.EXT_blend_func_separate dfactorRGB, GL.Enums.EXT_blend_func_separate sfactorAlpha, GL.Enums.EXT_blend_func_separate dfactorAlpha)
            {
                Delegates.glBlendFuncSeparateEXT((GL.Enums.EXT_blend_func_separate)sfactorRGB, (GL.Enums.EXT_blend_func_separate)dfactorRGB, (GL.Enums.EXT_blend_func_separate)sfactorAlpha, (GL.Enums.EXT_blend_func_separate)dfactorAlpha);
            }
            
            public static 
            void VertexWeightf(GLfloat weight)
            {
                Delegates.glVertexWeightfEXT((GLfloat)weight);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexWeightfv(GLfloat* weight)
            {
                unsafe { Delegates.glVertexWeightfvEXT((GLfloat*)weight); }
            }
            
            public static 
            void VertexWeightfv(GLfloat[] weight)
            {
                unsafe
                {
                    fixed (GLfloat* weight_ptr = weight)
                    {
                        Delegates.glVertexWeightfvEXT((GLfloat*)weight_ptr);
                    }
                }
            }
            
            public static 
            void VertexWeightfv(ref GLfloat weight)
            {
                unsafe
                {
                    fixed (GLfloat* weight_ptr = &weight)
                    {
                        Delegates.glVertexWeightfvEXT((GLfloat*)weight_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexWeightPointer(GLsizei size, GL.Enums.EXT_vertex_weighting type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glVertexWeightPointerEXT((GLsizei)size, (GL.Enums.EXT_vertex_weighting)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void VertexWeightPointer(GLsizei size, GL.Enums.EXT_vertex_weighting type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexWeightPointerEXT((GLsizei)size, (GL.Enums.EXT_vertex_weighting)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void SampleMask(GLclampf value, GL.Enums.Boolean invert)
            {
                 Delegates.glSampleMaskEXT((GLclampf)value, (GL.Enums.Boolean)invert); 
            }
            
            public static 
            void SamplePattern(GL.Enums.EXT_multisample pattern)
            {
                Delegates.glSamplePatternEXT((GL.Enums.EXT_multisample)pattern);
            }
            
            public static 
            void BeginVertexShader()
            {
                Delegates.glBeginVertexShaderEXT();
            }
            
            public static 
            void EndVertexShader()
            {
                Delegates.glEndVertexShaderEXT();
            }
            
            public static 
            void BindVertexShader(Int32 id)
            {
                Delegates.glBindVertexShaderEXT((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindVertexShader(GLuint id)
            {
                Delegates.glBindVertexShaderEXT((GLuint)id);
            }
            
            public static 
            Int32 GenVertexShaders(Int32 range)
            {
                return Delegates.glGenVertexShadersEXT((GLuint)range);
            }
            
            [System.CLSCompliant(false)]
            public static 
            Int32 GenVertexShaders(GLuint range)
            {
                return Delegates.glGenVertexShadersEXT((GLuint)range);
            }
            
            public static 
            void DeleteVertexShader(Int32 id)
            {
                Delegates.glDeleteVertexShaderEXT((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteVertexShader(GLuint id)
            {
                Delegates.glDeleteVertexShaderEXT((GLuint)id);
            }
            
            public static 
            void ShaderOp1(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1)
            {
                Delegates.glShaderOp1EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ShaderOp1(GL.Enums.EXT_vertex_shader op, GLuint res, GLuint arg1)
            {
                Delegates.glShaderOp1EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1);
            }
            
            public static 
            void ShaderOp2(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1, Int32 arg2)
            {
                Delegates.glShaderOp2EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1, (GLuint)arg2);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ShaderOp2(GL.Enums.EXT_vertex_shader op, GLuint res, GLuint arg1, GLuint arg2)
            {
                Delegates.glShaderOp2EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1, (GLuint)arg2);
            }
            
            public static 
            void ShaderOp3(GL.Enums.EXT_vertex_shader op, Int32 res, Int32 arg1, Int32 arg2, Int32 arg3)
            {
                Delegates.glShaderOp3EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1, (GLuint)arg2, (GLuint)arg3);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ShaderOp3(GL.Enums.EXT_vertex_shader op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3)
            {
                Delegates.glShaderOp3EXT((GL.Enums.EXT_vertex_shader)op, (GLuint)res, (GLuint)arg1, (GLuint)arg2, (GLuint)arg3);
            }
            
            public static 
            void Swizzle(Int32 res, Int32 @in, GL.Enums.EXT_vertex_shader outX, GL.Enums.EXT_vertex_shader outY, GL.Enums.EXT_vertex_shader outZ, GL.Enums.EXT_vertex_shader outW)
            {
                Delegates.glSwizzleEXT((GLuint)res, (GLuint)@in, (GL.Enums.EXT_vertex_shader)outX, (GL.Enums.EXT_vertex_shader)outY, (GL.Enums.EXT_vertex_shader)outZ, (GL.Enums.EXT_vertex_shader)outW);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Swizzle(GLuint res, GLuint @in, GL.Enums.EXT_vertex_shader outX, GL.Enums.EXT_vertex_shader outY, GL.Enums.EXT_vertex_shader outZ, GL.Enums.EXT_vertex_shader outW)
            {
                Delegates.glSwizzleEXT((GLuint)res, (GLuint)@in, (GL.Enums.EXT_vertex_shader)outX, (GL.Enums.EXT_vertex_shader)outY, (GL.Enums.EXT_vertex_shader)outZ, (GL.Enums.EXT_vertex_shader)outW);
            }
            
            public static 
            void WriteMask(Int32 res, Int32 @in, GL.Enums.EXT_vertex_shader outX, GL.Enums.EXT_vertex_shader outY, GL.Enums.EXT_vertex_shader outZ, GL.Enums.EXT_vertex_shader outW)
            {
                Delegates.glWriteMaskEXT((GLuint)res, (GLuint)@in, (GL.Enums.EXT_vertex_shader)outX, (GL.Enums.EXT_vertex_shader)outY, (GL.Enums.EXT_vertex_shader)outZ, (GL.Enums.EXT_vertex_shader)outW);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void WriteMask(GLuint res, GLuint @in, GL.Enums.EXT_vertex_shader outX, GL.Enums.EXT_vertex_shader outY, GL.Enums.EXT_vertex_shader outZ, GL.Enums.EXT_vertex_shader outW)
            {
                Delegates.glWriteMaskEXT((GLuint)res, (GLuint)@in, (GL.Enums.EXT_vertex_shader)outX, (GL.Enums.EXT_vertex_shader)outY, (GL.Enums.EXT_vertex_shader)outZ, (GL.Enums.EXT_vertex_shader)outW);
            }
            
            public static 
            void InsertComponent(Int32 res, Int32 src, Int32 num)
            {
                Delegates.glInsertComponentEXT((GLuint)res, (GLuint)src, (GLuint)num);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void InsertComponent(GLuint res, GLuint src, GLuint num)
            {
                Delegates.glInsertComponentEXT((GLuint)res, (GLuint)src, (GLuint)num);
            }
            
            public static 
            void ExtractComponent(Int32 res, Int32 src, Int32 num)
            {
                Delegates.glExtractComponentEXT((GLuint)res, (GLuint)src, (GLuint)num);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ExtractComponent(GLuint res, GLuint src, GLuint num)
            {
                Delegates.glExtractComponentEXT((GLuint)res, (GLuint)src, (GLuint)num);
            }
            
            public static 
            Int32 GenSymbols(GL.Enums.EXT_vertex_shader datatype, GL.Enums.EXT_vertex_shader storagetype, GL.Enums.EXT_vertex_shader range, Int32 components)
            {
                return Delegates.glGenSymbolsEXT((GL.Enums.EXT_vertex_shader)datatype, (GL.Enums.EXT_vertex_shader)storagetype, (GL.Enums.EXT_vertex_shader)range, (GLuint)components);
            }
            
            [System.CLSCompliant(false)]
            public static 
            Int32 GenSymbols(GL.Enums.EXT_vertex_shader datatype, GL.Enums.EXT_vertex_shader storagetype, GL.Enums.EXT_vertex_shader range, GLuint components)
            {
                return Delegates.glGenSymbolsEXT((GL.Enums.EXT_vertex_shader)datatype, (GL.Enums.EXT_vertex_shader)storagetype, (GL.Enums.EXT_vertex_shader)range, (GLuint)components);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SetInvariant(Int32 id, GL.Enums.EXT_vertex_shader type, void* addr)
            {
                    {
                        Delegates.glSetInvariantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SetInvariant(GLuint id, GL.Enums.EXT_vertex_shader type, void* addr)
            {
                unsafe { Delegates.glSetInvariantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr); }
            }
            
            public static 
            void SetInvariant(Int32 id, GL.Enums.EXT_vertex_shader type, object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glSetInvariantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        addr_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SetInvariant(GLuint id, GL.Enums.EXT_vertex_shader type, object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glSetInvariantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        addr_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SetLocalConstant(Int32 id, GL.Enums.EXT_vertex_shader type, void* addr)
            {
                    {
                        Delegates.glSetLocalConstantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SetLocalConstant(GLuint id, GL.Enums.EXT_vertex_shader type, void* addr)
            {
                unsafe { Delegates.glSetLocalConstantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr); }
            }
            
            public static 
            void SetLocalConstant(Int32 id, GL.Enums.EXT_vertex_shader type, object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glSetLocalConstantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        addr_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SetLocalConstant(GLuint id, GL.Enums.EXT_vertex_shader type, object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glSetLocalConstantEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (void*)addr_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        addr_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantbv(Int32 id, Byte* addr)
            {
                    {
                        Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantbv(GLuint id, GLbyte* addr)
            {
                unsafe { Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr); }
            }
            
            public static 
            void Variantbv(Int32 id, Byte[] addr)
            {
                unsafe
                {
                    fixed (Byte* addr_ptr = addr)
                    {
                        Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantbv(GLuint id, GLbyte[] addr)
            {
                unsafe
                {
                    fixed (GLbyte* addr_ptr = addr)
                    {
                        Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr_ptr);
                    }
                }
            }
            
            public static 
            void Variantbv(Int32 id, ref Byte addr)
            {
                unsafe
                {
                    fixed (Byte* addr_ptr = &addr)
                    {
                        Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantbv(GLuint id, ref GLbyte addr)
            {
                unsafe
                {
                    fixed (GLbyte* addr_ptr = &addr)
                    {
                        Delegates.glVariantbvEXT((GLuint)id, (GLbyte*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantsv(Int32 id, GLshort* addr)
            {
                    {
                        Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantsv(GLuint id, GLshort* addr)
            {
                unsafe { Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr); }
            }
            
            public static 
            void Variantsv(Int32 id, GLshort[] addr)
            {
                unsafe
                {
                    fixed (GLshort* addr_ptr = addr)
                    {
                        Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantsv(GLuint id, GLshort[] addr)
            {
                unsafe
                {
                    fixed (GLshort* addr_ptr = addr)
                    {
                        Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr_ptr);
                    }
                }
            }
            
            public static 
            void Variantsv(Int32 id, ref GLshort addr)
            {
                unsafe
                {
                    fixed (GLshort* addr_ptr = &addr)
                    {
                        Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantsv(GLuint id, ref GLshort addr)
            {
                unsafe
                {
                    fixed (GLshort* addr_ptr = &addr)
                    {
                        Delegates.glVariantsvEXT((GLuint)id, (GLshort*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantiv(Int32 id, GLint* addr)
            {
                    {
                        Delegates.glVariantivEXT((GLuint)id, (GLint*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantiv(GLuint id, GLint* addr)
            {
                unsafe { Delegates.glVariantivEXT((GLuint)id, (GLint*)addr); }
            }
            
            public static 
            void Variantiv(Int32 id, GLint[] addr)
            {
                unsafe
                {
                    fixed (GLint* addr_ptr = addr)
                    {
                        Delegates.glVariantivEXT((GLuint)id, (GLint*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantiv(GLuint id, GLint[] addr)
            {
                unsafe
                {
                    fixed (GLint* addr_ptr = addr)
                    {
                        Delegates.glVariantivEXT((GLuint)id, (GLint*)addr_ptr);
                    }
                }
            }
            
            public static 
            void Variantiv(Int32 id, ref GLint addr)
            {
                unsafe
                {
                    fixed (GLint* addr_ptr = &addr)
                    {
                        Delegates.glVariantivEXT((GLuint)id, (GLint*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantiv(GLuint id, ref GLint addr)
            {
                unsafe
                {
                    fixed (GLint* addr_ptr = &addr)
                    {
                        Delegates.glVariantivEXT((GLuint)id, (GLint*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantfv(Int32 id, GLfloat* addr)
            {
                    {
                        Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantfv(GLuint id, GLfloat* addr)
            {
                unsafe { Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr); }
            }
            
            public static 
            void Variantfv(Int32 id, GLfloat[] addr)
            {
                unsafe
                {
                    fixed (GLfloat* addr_ptr = addr)
                    {
                        Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantfv(GLuint id, GLfloat[] addr)
            {
                unsafe
                {
                    fixed (GLfloat* addr_ptr = addr)
                    {
                        Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr_ptr);
                    }
                }
            }
            
            public static 
            void Variantfv(Int32 id, ref GLfloat addr)
            {
                unsafe
                {
                    fixed (GLfloat* addr_ptr = &addr)
                    {
                        Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantfv(GLuint id, ref GLfloat addr)
            {
                unsafe
                {
                    fixed (GLfloat* addr_ptr = &addr)
                    {
                        Delegates.glVariantfvEXT((GLuint)id, (GLfloat*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantdv(Int32 id, GLdouble* addr)
            {
                    {
                        Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantdv(GLuint id, GLdouble* addr)
            {
                unsafe { Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr); }
            }
            
            public static 
            void Variantdv(Int32 id, GLdouble[] addr)
            {
                unsafe
                {
                    fixed (GLdouble* addr_ptr = addr)
                    {
                        Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantdv(GLuint id, GLdouble[] addr)
            {
                unsafe
                {
                    fixed (GLdouble* addr_ptr = addr)
                    {
                        Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr_ptr);
                    }
                }
            }
            
            public static 
            void Variantdv(Int32 id, ref GLdouble addr)
            {
                unsafe
                {
                    fixed (GLdouble* addr_ptr = &addr)
                    {
                        Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantdv(GLuint id, ref GLdouble addr)
            {
                unsafe
                {
                    fixed (GLdouble* addr_ptr = &addr)
                    {
                        Delegates.glVariantdvEXT((GLuint)id, (GLdouble*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantubv(Int32 id, GLubyte* addr)
            {
                    {
                        Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantubv(GLuint id, GLubyte* addr)
            {
                unsafe { Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr); }
            }
            
            public static 
            void Variantubv(Int32 id, GLubyte[] addr)
            {
                unsafe
                {
                    fixed (GLubyte* addr_ptr = addr)
                    {
                        Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantubv(GLuint id, GLubyte[] addr)
            {
                unsafe
                {
                    fixed (GLubyte* addr_ptr = addr)
                    {
                        Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr_ptr);
                    }
                }
            }
            
            public static 
            void Variantubv(Int32 id, ref GLubyte addr)
            {
                unsafe
                {
                    fixed (GLubyte* addr_ptr = &addr)
                    {
                        Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantubv(GLuint id, ref GLubyte addr)
            {
                unsafe
                {
                    fixed (GLubyte* addr_ptr = &addr)
                    {
                        Delegates.glVariantubvEXT((GLuint)id, (GLubyte*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantusv(Int32 id, Int16* addr)
            {
                    {
                        Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantusv(GLuint id, GLushort* addr)
            {
                unsafe { Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr); }
            }
            
            public static 
            void Variantusv(Int32 id, Int16[] addr)
            {
                unsafe
                {
                    fixed (Int16* addr_ptr = addr)
                    {
                        Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantusv(GLuint id, GLushort[] addr)
            {
                unsafe
                {
                    fixed (GLushort* addr_ptr = addr)
                    {
                        Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr_ptr);
                    }
                }
            }
            
            public static 
            void Variantusv(Int32 id, ref Int16 addr)
            {
                unsafe
                {
                    fixed (Int16* addr_ptr = &addr)
                    {
                        Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantusv(GLuint id, ref GLushort addr)
            {
                unsafe
                {
                    fixed (GLushort* addr_ptr = &addr)
                    {
                        Delegates.glVariantusvEXT((GLuint)id, (GLushort*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantuiv(Int32 id, Int32* addr)
            {
                    {
                        Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Variantuiv(GLuint id, GLuint* addr)
            {
                unsafe { Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr); }
            }
            
            public static 
            void Variantuiv(Int32 id, Int32[] addr)
            {
                unsafe
                {
                    fixed (Int32* addr_ptr = addr)
                    {
                        Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantuiv(GLuint id, GLuint[] addr)
            {
                unsafe
                {
                    fixed (GLuint* addr_ptr = addr)
                    {
                        Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr_ptr);
                    }
                }
            }
            
            public static 
            void Variantuiv(Int32 id, ref Int32 addr)
            {
                unsafe
                {
                    fixed (Int32* addr_ptr = &addr)
                    {
                        Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Variantuiv(GLuint id, ref GLuint addr)
            {
                unsafe
                {
                    fixed (GLuint* addr_ptr = &addr)
                    {
                        Delegates.glVariantuivEXT((GLuint)id, (GLuint*)addr_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VariantPointer(Int32 id, GL.Enums.EXT_vertex_shader type, Int32 stride, void* addr)
            {
                    {
                        Delegates.glVariantPointerEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (GLuint)stride, (void*)addr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VariantPointer(GLuint id, GL.Enums.EXT_vertex_shader type, GLuint stride, void* addr)
            {
                unsafe { Delegates.glVariantPointerEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (GLuint)stride, (void*)addr); }
            }
            
            public static 
            void VariantPointer(Int32 id, GL.Enums.EXT_vertex_shader type, Int32 stride, object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVariantPointerEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (GLuint)stride, (void*)addr_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        addr_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VariantPointer(GLuint id, GL.Enums.EXT_vertex_shader type, GLuint stride, object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVariantPointerEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)type, (GLuint)stride, (void*)addr_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        addr_ptr.Free();
                    }
                }
            }
            
            public static 
            void EnableVariantClientState(Int32 id)
            {
                Delegates.glEnableVariantClientStateEXT((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void EnableVariantClientState(GLuint id)
            {
                Delegates.glEnableVariantClientStateEXT((GLuint)id);
            }
            
            public static 
            void DisableVariantClientState(Int32 id)
            {
                Delegates.glDisableVariantClientStateEXT((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DisableVariantClientState(GLuint id)
            {
                Delegates.glDisableVariantClientStateEXT((GLuint)id);
            }
            
            public static 
            Int32 BindLightParameter(GL.Enums.LightName light, GL.Enums.LightParameter value)
            {
                return Delegates.glBindLightParameterEXT((GL.Enums.LightName)light, (GL.Enums.LightParameter)value);
            }
            
            public static 
            Int32 BindMaterialParameter(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter value)
            {
                return Delegates.glBindMaterialParameterEXT((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)value);
            }
            
            public static 
            Int32 BindTexGenParameter(GL.Enums.EXT_vertex_shader unit, GL.Enums.TextureCoordName coord, GL.Enums.TextureGenParameter value)
            {
                return Delegates.glBindTexGenParameterEXT((GL.Enums.EXT_vertex_shader)unit, (GL.Enums.TextureCoordName)coord, (GL.Enums.TextureGenParameter)value);
            }
            
            public static 
            Int32 BindTextureUnitParameter(GL.Enums.EXT_vertex_shader unit, GL.Enums.EXT_vertex_shader value)
            {
                return Delegates.glBindTextureUnitParameterEXT((GL.Enums.EXT_vertex_shader)unit, (GL.Enums.EXT_vertex_shader)value);
            }
            
            public static 
            Int32 BindParameter(GL.Enums.EXT_vertex_shader value)
            {
                return Delegates.glBindParameterEXT((GL.Enums.EXT_vertex_shader)value);
            }
            
            public static 
            GLboolean IsVariantEnabled(Int32 id, GL.Enums.EXT_vertex_shader cap)
            {
                return Delegates.glIsVariantEnabledEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)cap);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsVariantEnabled(GLuint id, GL.Enums.EXT_vertex_shader cap)
            {
                return Delegates.glIsVariantEnabledEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)cap);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantBooleanv(Int32 id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
            {
                data = default(GL.Enums.Boolean*);
                    {
                        Delegates.glGetVariantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantBooleanv(GLuint id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
            {
                unsafe { Delegates.glGetVariantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint* data)
            {
                data = default(GLint*);
                    {
                        Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint* data)
            {
                unsafe { Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data); }
            }
            
            public static 
            void GetVariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint[] data)
            {
                unsafe
                {
                    fixed (GLint* data_ptr = data)
                    {
                        Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint[] data)
            {
                unsafe
                {
                    fixed (GLint* data_ptr = data)
                    {
                        Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                    }
                }
            }
            
            public static 
            void GetVariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLint data)
            {
                data = default(GLint);
                unsafe
                {
                    fixed (GLint* data_ptr = &data)
                    {
                        Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLint data)
            {
                data = default(GLint);
                unsafe
                {
                    fixed (GLint* data_ptr = &data)
                    {
                        Delegates.glGetVariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
            {
                data = default(GLfloat*);
                    {
                        Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
            {
                unsafe { Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data); }
            }
            
            public static 
            void GetVariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
            {
                unsafe
                {
                    fixed (GLfloat* data_ptr = data)
                    {
                        Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
            {
                unsafe
                {
                    fixed (GLfloat* data_ptr = data)
                    {
                        Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                    }
                }
            }
            
            public static 
            void GetVariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
            {
                data = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* data_ptr = &data)
                    {
                        Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
            {
                data = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* data_ptr = &data)
                    {
                        Delegates.glGetVariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantPointerv(Int32 id, GL.Enums.EXT_vertex_shader value, void* data)
            {
                data = default(void*);
                    {
                        Delegates.glGetVariantPointervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (void*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantPointerv(GLuint id, GL.Enums.EXT_vertex_shader value, void* data)
            {
                unsafe { Delegates.glGetVariantPointervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (void*)data); }
            }
            
            public static 
            void GetVariantPointerv(Int32 id, GL.Enums.EXT_vertex_shader value, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetVariantPointervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantPointerv(GLuint id, GL.Enums.EXT_vertex_shader value, object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetVariantPointervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (void*)data_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        data_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantBooleanv(Int32 id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
            {
                data = default(GL.Enums.Boolean*);
                    {
                        Delegates.glGetInvariantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantBooleanv(GLuint id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
            {
                unsafe { Delegates.glGetInvariantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint* data)
            {
                data = default(GLint*);
                    {
                        Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint* data)
            {
                unsafe { Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data); }
            }
            
            public static 
            void GetInvariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint[] data)
            {
                unsafe
                {
                    fixed (GLint* data_ptr = data)
                    {
                        Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetInvariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint[] data)
            {
                unsafe
                {
                    fixed (GLint* data_ptr = data)
                    {
                        Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                    }
                }
            }
            
            public static 
            void GetInvariantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLint data)
            {
                data = default(GLint);
                unsafe
                {
                    fixed (GLint* data_ptr = &data)
                    {
                        Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetInvariantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLint data)
            {
                data = default(GLint);
                unsafe
                {
                    fixed (GLint* data_ptr = &data)
                    {
                        Delegates.glGetInvariantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
            {
                data = default(GLfloat*);
                    {
                        Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
            {
                unsafe { Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data); }
            }
            
            public static 
            void GetInvariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
            {
                unsafe
                {
                    fixed (GLfloat* data_ptr = data)
                    {
                        Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetInvariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
            {
                unsafe
                {
                    fixed (GLfloat* data_ptr = data)
                    {
                        Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                    }
                }
            }
            
            public static 
            void GetInvariantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
            {
                data = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* data_ptr = &data)
                    {
                        Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetInvariantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
            {
                data = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* data_ptr = &data)
                    {
                        Delegates.glGetInvariantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantBooleanv(Int32 id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
            {
                data = default(GL.Enums.Boolean*);
                    {
                        Delegates.glGetLocalConstantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantBooleanv(GLuint id, GL.Enums.EXT_vertex_shader value, GL.Enums.Boolean* data)
            {
                unsafe { Delegates.glGetLocalConstantBooleanvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GL.Enums.Boolean*)data); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint* data)
            {
                data = default(GLint*);
                    {
                        Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint* data)
            {
                unsafe { Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data); }
            }
            
            public static 
            void GetLocalConstantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, GLint[] data)
            {
                unsafe
                {
                    fixed (GLint* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, GLint[] data)
            {
                unsafe
                {
                    fixed (GLint* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                    }
                }
            }
            
            public static 
            void GetLocalConstantIntegerv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLint data)
            {
                data = default(GLint);
                unsafe
                {
                    fixed (GLint* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantIntegerv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLint data)
            {
                data = default(GLint);
                unsafe
                {
                    fixed (GLint* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantIntegervEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLint*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
            {
                data = default(GLfloat*);
                    {
                        Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat* data)
            {
                unsafe { Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data); }
            }
            
            public static 
            void GetLocalConstantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
            {
                unsafe
                {
                    fixed (GLfloat* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, GLfloat[] data)
            {
                unsafe
                {
                    fixed (GLfloat* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                    }
                }
            }
            
            public static 
            void GetLocalConstantFloatv(Int32 id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
            {
                data = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantFloatv(GLuint id, GL.Enums.EXT_vertex_shader value, out GLfloat data)
            {
                data = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantFloatvEXT((GLuint)id, (GL.Enums.EXT_vertex_shader)value, (GLfloat*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            public static 
            void ActiveStencilFace(GL.Enums.EXT_stencil_two_side face)
            {
                Delegates.glActiveStencilFaceEXT((GL.Enums.EXT_stencil_two_side)face);
            }
            
            public static 
            void DepthBounds(GLclampd zmin, GLclampd zmax)
            {
                Delegates.glDepthBoundsEXT((GLclampd)zmin, (GLclampd)zmax);
            }
            
            public static 
            void BlendEquationSeparate(GL.Enums.BlendEquationModeEXT modeRGB, GL.Enums.BlendEquationModeEXT modeAlpha)
            {
                Delegates.glBlendEquationSeparateEXT((GL.Enums.BlendEquationModeEXT)modeRGB, (GL.Enums.BlendEquationModeEXT)modeAlpha);
            }
            
            public static 
            GLboolean IsRenderbuffer(Int32 renderbuffer)
            {
                return Delegates.glIsRenderbufferEXT((GLuint)renderbuffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsRenderbuffer(GLuint renderbuffer)
            {
                return Delegates.glIsRenderbufferEXT((GLuint)renderbuffer);
            }
            
            public static 
            void BindRenderbuffer(GL.Enums.EXT_framebuffer_object target, Int32 renderbuffer)
            {
                Delegates.glBindRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GLuint)renderbuffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindRenderbuffer(GL.Enums.EXT_framebuffer_object target, GLuint renderbuffer)
            {
                Delegates.glBindRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GLuint)renderbuffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteRenderbuffers(GLsizei n, Int32* renderbuffers)
            {
                    {
                        Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteRenderbuffers(GLsizei n, GLuint* renderbuffers)
            {
                unsafe { Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers); }
            }
            
            public static 
            void DeleteRenderbuffers(GLsizei n, Int32[] renderbuffers)
            {
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = renderbuffers)
                    {
                        Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteRenderbuffers(GLsizei n, GLuint[] renderbuffers)
            {
                unsafe
                {
                    fixed (GLuint* renderbuffers_ptr = renderbuffers)
                    {
                        Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
                    }
                }
            }
            
            public static 
            void DeleteRenderbuffers(GLsizei n, ref Int32 renderbuffers)
            {
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = &renderbuffers)
                    {
                        Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteRenderbuffers(GLsizei n, ref GLuint renderbuffers)
            {
                unsafe
                {
                    fixed (GLuint* renderbuffers_ptr = &renderbuffers)
                    {
                        Delegates.glDeleteRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenRenderbuffers(GLsizei n, Int32* renderbuffers)
            {
                renderbuffers = default(Int32*);
                    {
                        Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
            {
                unsafe { Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers); }
            }
            
            public static 
            void GenRenderbuffers(GLsizei n, Int32[] renderbuffers)
            {
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = renderbuffers)
                    {
                        Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenRenderbuffers(GLsizei n, GLuint[] renderbuffers)
            {
                unsafe
                {
                    fixed (GLuint* renderbuffers_ptr = renderbuffers)
                    {
                        Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
                    }
                }
            }
            
            public static 
            void GenRenderbuffers(GLsizei n, out Int32 renderbuffers)
            {
                renderbuffers = default(Int32);
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = &renderbuffers)
                    {
                        Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
                        renderbuffers = *renderbuffers_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenRenderbuffers(GLsizei n, out GLuint renderbuffers)
            {
                renderbuffers = default(GLuint);
                unsafe
                {
                    fixed (GLuint* renderbuffers_ptr = &renderbuffers)
                    {
                        Delegates.glGenRenderbuffersEXT((GLsizei)n, (GLuint*)renderbuffers_ptr);
                        renderbuffers = *renderbuffers_ptr;
                    }
                }
            }
            
            public static 
            void RenderbufferStorage(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object internalformat, GLsizei width, GLsizei height)
            {
                Delegates.glRenderbufferStorageEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)internalformat, (GLsizei)width, (GLsizei)height);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetRenderbufferParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, GLint* @params)
            {
                unsafe { Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params); }
            }
            
            public static 
            void GetRenderbufferParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetRenderbufferParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetRenderbufferParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            GLboolean IsFramebuffer(Int32 framebuffer)
            {
                return Delegates.glIsFramebufferEXT((GLuint)framebuffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsFramebuffer(GLuint framebuffer)
            {
                return Delegates.glIsFramebufferEXT((GLuint)framebuffer);
            }
            
            public static 
            void BindFramebuffer(GL.Enums.EXT_framebuffer_object target, Int32 framebuffer)
            {
                Delegates.glBindFramebufferEXT((GL.Enums.EXT_framebuffer_object)target, (GLuint)framebuffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindFramebuffer(GL.Enums.EXT_framebuffer_object target, GLuint framebuffer)
            {
                Delegates.glBindFramebufferEXT((GL.Enums.EXT_framebuffer_object)target, (GLuint)framebuffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFramebuffers(GLsizei n, Int32* framebuffers)
            {
                    {
                        Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFramebuffers(GLsizei n, GLuint* framebuffers)
            {
                unsafe { Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers); }
            }
            
            public static 
            void DeleteFramebuffers(GLsizei n, Int32[] framebuffers)
            {
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = framebuffers)
                    {
                        Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteFramebuffers(GLsizei n, GLuint[] framebuffers)
            {
                unsafe
                {
                    fixed (GLuint* framebuffers_ptr = framebuffers)
                    {
                        Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
                    }
                }
            }
            
            public static 
            void DeleteFramebuffers(GLsizei n, ref Int32 framebuffers)
            {
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = &framebuffers)
                    {
                        Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteFramebuffers(GLsizei n, ref GLuint framebuffers)
            {
                unsafe
                {
                    fixed (GLuint* framebuffers_ptr = &framebuffers)
                    {
                        Delegates.glDeleteFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFramebuffers(GLsizei n, Int32* framebuffers)
            {
                framebuffers = default(Int32*);
                    {
                        Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFramebuffers(GLsizei n, GLuint* framebuffers)
            {
                unsafe { Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers); }
            }
            
            public static 
            void GenFramebuffers(GLsizei n, Int32[] framebuffers)
            {
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = framebuffers)
                    {
                        Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenFramebuffers(GLsizei n, GLuint[] framebuffers)
            {
                unsafe
                {
                    fixed (GLuint* framebuffers_ptr = framebuffers)
                    {
                        Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
                    }
                }
            }
            
            public static 
            void GenFramebuffers(GLsizei n, out Int32 framebuffers)
            {
                framebuffers = default(Int32);
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = &framebuffers)
                    {
                        Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
                        framebuffers = *framebuffers_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenFramebuffers(GLsizei n, out GLuint framebuffers)
            {
                framebuffers = default(GLuint);
                unsafe
                {
                    fixed (GLuint* framebuffers_ptr = &framebuffers)
                    {
                        Delegates.glGenFramebuffersEXT((GLsizei)n, (GLuint*)framebuffers_ptr);
                        framebuffers = *framebuffers_ptr;
                    }
                }
            }
            
            public static 
            GL.Enums.GLenum CheckFramebufferStatus(GL.Enums.EXT_framebuffer_object target)
            {
                return Delegates.glCheckFramebufferStatusEXT((GL.Enums.EXT_framebuffer_object)target);
            }
            
            public static 
            void FramebufferTexture1D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, GLint level)
            {
                Delegates.glFramebufferTexture1DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FramebufferTexture1D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level)
            {
                Delegates.glFramebufferTexture1DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level);
            }
            
            public static 
            void FramebufferTexture2D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, GLint level)
            {
                Delegates.glFramebufferTexture2DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FramebufferTexture2D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level)
            {
                Delegates.glFramebufferTexture2DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level);
            }
            
            public static 
            void FramebufferTexture3D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, Int32 texture, GLint level, GLint zoffset)
            {
                Delegates.glFramebufferTexture3DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level, (GLint)zoffset);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FramebufferTexture3D(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level, GLint zoffset)
            {
                Delegates.glFramebufferTexture3DEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)textarget, (GLuint)texture, (GLint)level, (GLint)zoffset);
            }
            
            public static 
            void FramebufferRenderbuffer(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object renderbuffertarget, Int32 renderbuffer)
            {
                Delegates.glFramebufferRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)renderbuffertarget, (GLuint)renderbuffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FramebufferRenderbuffer(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object renderbuffertarget, GLuint renderbuffer)
            {
                Delegates.glFramebufferRenderbufferEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)renderbuffertarget, (GLuint)renderbuffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFramebufferAttachmentParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, GLint* @params)
            {
                unsafe { Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params); }
            }
            
            public static 
            void GetFramebufferAttachmentParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetFramebufferAttachmentParameteriv(GL.Enums.EXT_framebuffer_object target, GL.Enums.EXT_framebuffer_object attachment, GL.Enums.EXT_framebuffer_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetFramebufferAttachmentParameterivEXT((GL.Enums.EXT_framebuffer_object)target, (GL.Enums.EXT_framebuffer_object)attachment, (GL.Enums.EXT_framebuffer_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void GenerateMipmap(GL.Enums.EXT_framebuffer_object target)
            {
                Delegates.glGenerateMipmapEXT((GL.Enums.EXT_framebuffer_object)target);
            }
            
            public static 
            void StencilClearTag(GLsizei stencilTagBits, Int32 stencilClearTag)
            {
                Delegates.glStencilClearTagEXT((GLsizei)stencilTagBits, (GLuint)stencilClearTag);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void StencilClearTag(GLsizei stencilTagBits, GLuint stencilClearTag)
            {
                Delegates.glStencilClearTagEXT((GLsizei)stencilTagBits, (GLuint)stencilClearTag);
            }
            
            public static 
            void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GL.Enums.ClearBufferMask mask, GL.Enums.EXT_framebuffer_blit filter)
            {
                Delegates.glBlitFramebufferEXT((GLint)srcX0, (GLint)srcY0, (GLint)srcX1, (GLint)srcY1, (GLint)dstX0, (GLint)dstY0, (GLint)dstX1, (GLint)dstY1, (GL.Enums.ClearBufferMask)mask, (GL.Enums.EXT_framebuffer_blit)filter);
            }
            
            public static 
            void RenderbufferStorageMultisample(GL.Enums.EXT_framebuffer_multisample target, GLsizei samples, GL.Enums.EXT_framebuffer_multisample internalformat, GLsizei width, GLsizei height)
            {
                Delegates.glRenderbufferStorageMultisampleEXT((GL.Enums.EXT_framebuffer_multisample)target, (GLsizei)samples, (GL.Enums.EXT_framebuffer_multisample)internalformat, (GLsizei)width, (GLsizei)height);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjecti64v(Int32 id, GL.Enums.EXT_timer_query pname, GLint64EXT* @params)
            {
                @params = default(GLint64EXT*);
                    {
                        Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjecti64v(GLuint id, GL.Enums.EXT_timer_query pname, GLint64EXT* @params)
            {
                unsafe { Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params); }
            }
            
            public static 
            void GetQueryObjecti64v(Int32 id, GL.Enums.EXT_timer_query pname, GLint64EXT[] @params)
            {
                unsafe
                {
                    fixed (GLint64EXT* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjecti64v(GLuint id, GL.Enums.EXT_timer_query pname, GLint64EXT[] @params)
            {
                unsafe
                {
                    fixed (GLint64EXT* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetQueryObjecti64v(Int32 id, GL.Enums.EXT_timer_query pname, out GLint64EXT @params)
            {
                @params = default(GLint64EXT);
                unsafe
                {
                    fixed (GLint64EXT* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjecti64v(GLuint id, GL.Enums.EXT_timer_query pname, out GLint64EXT @params)
            {
                @params = default(GLint64EXT);
                unsafe
                {
                    fixed (GLint64EXT* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjecti64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLint64EXT*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjectui64v(Int32 id, GL.Enums.EXT_timer_query pname, Int64* @params)
            {
                @params = default(Int64*);
                    {
                        Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjectui64v(GLuint id, GL.Enums.EXT_timer_query pname, GLuint64EXT* @params)
            {
                unsafe { Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params); }
            }
            
            public static 
            void GetQueryObjectui64v(Int32 id, GL.Enums.EXT_timer_query pname, Int64[] @params)
            {
                unsafe
                {
                    fixed (Int64* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjectui64v(GLuint id, GL.Enums.EXT_timer_query pname, GLuint64EXT[] @params)
            {
                unsafe
                {
                    fixed (GLuint64EXT* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetQueryObjectui64v(Int32 id, GL.Enums.EXT_timer_query pname, out Int64 @params)
            {
                @params = default(Int64);
                unsafe
                {
                    fixed (Int64* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjectui64v(GLuint id, GL.Enums.EXT_timer_query pname, out GLuint64EXT @params)
            {
                @params = default(GLuint64EXT);
                unsafe
                {
                    fixed (GLuint64EXT* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectui64vEXT((GLuint)id, (GL.Enums.EXT_timer_query)pname, (GLuint64EXT*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, GLfloat* @params)
            {
                    {
                        Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat* @params)
            {
                unsafe { Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params); }
            }
            
            public static 
            void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, GLfloat* @params)
            {
                    {
                        Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat* @params)
            {
                unsafe { Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params); }
            }
            
            public static 
            void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, Int32 index, GLsizei count, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameters4fv(GL.Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameters4fvEXT((GL.Enums.EXT_gpu_program_parameters)target, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FramebufferTexture(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, GLint level)
            {
                Delegates.glFramebufferTextureEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FramebufferTexture(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, GLuint texture, GLint level)
            {
                Delegates.glFramebufferTextureEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level);
            }
            
            public static 
            void FramebufferTextureLayer(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, GLint level, GLint layer)
            {
                Delegates.glFramebufferTextureLayerEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level, (GLint)layer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FramebufferTextureLayer(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, GLuint texture, GLint level, GLint layer)
            {
                Delegates.glFramebufferTextureLayerEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level, (GLint)layer);
            }
            
            public static 
            void FramebufferTextureFace(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, Int32 texture, GLint level, GL.Enums.TextureTarget face)
            {
                Delegates.glFramebufferTextureFaceEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level, (GL.Enums.TextureTarget)face);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FramebufferTextureFace(GL.Enums.NV_geometry_program4 target, GL.Enums.NV_geometry_program4 attachment, GLuint texture, GLint level, GL.Enums.TextureTarget face)
            {
                Delegates.glFramebufferTextureFaceEXT((GL.Enums.NV_geometry_program4)target, (GL.Enums.NV_geometry_program4)attachment, (GLuint)texture, (GLint)level, (GL.Enums.TextureTarget)face);
            }
            
            public static 
            void ProgramParameteri(Int32 program, GL.Enums.EXT_geometry_shader4 pname, GLint value)
            {
                Delegates.glProgramParameteriEXT((GLuint)program, (GL.Enums.EXT_geometry_shader4)pname, (GLint)value);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameteri(GLuint program, GL.Enums.EXT_geometry_shader4 pname, GLint value)
            {
                Delegates.glProgramParameteriEXT((GLuint)program, (GL.Enums.EXT_geometry_shader4)pname, (GLint)value);
            }
            
            public static 
            void VertexAttribI1i(Int32 index, GLint x)
            {
                Delegates.glVertexAttribI1iEXT((GLuint)index, (GLint)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1i(GLuint index, GLint x)
            {
                Delegates.glVertexAttribI1iEXT((GLuint)index, (GLint)x);
            }
            
            public static 
            void VertexAttribI2i(Int32 index, GLint x, GLint y)
            {
                Delegates.glVertexAttribI2iEXT((GLuint)index, (GLint)x, (GLint)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2i(GLuint index, GLint x, GLint y)
            {
                Delegates.glVertexAttribI2iEXT((GLuint)index, (GLint)x, (GLint)y);
            }
            
            public static 
            void VertexAttribI3i(Int32 index, GLint x, GLint y, GLint z)
            {
                Delegates.glVertexAttribI3iEXT((GLuint)index, (GLint)x, (GLint)y, (GLint)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
            {
                Delegates.glVertexAttribI3iEXT((GLuint)index, (GLint)x, (GLint)y, (GLint)z);
            }
            
            public static 
            void VertexAttribI4i(Int32 index, GLint x, GLint y, GLint z, GLint w)
            {
                Delegates.glVertexAttribI4iEXT((GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
            {
                Delegates.glVertexAttribI4iEXT((GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
            }
            
            public static 
            void VertexAttribI1ui(Int32 index, Int32 x)
            {
                Delegates.glVertexAttribI1uiEXT((GLuint)index, (GLuint)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1ui(GLuint index, GLuint x)
            {
                Delegates.glVertexAttribI1uiEXT((GLuint)index, (GLuint)x);
            }
            
            public static 
            void VertexAttribI2ui(Int32 index, Int32 x, Int32 y)
            {
                Delegates.glVertexAttribI2uiEXT((GLuint)index, (GLuint)x, (GLuint)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
            {
                Delegates.glVertexAttribI2uiEXT((GLuint)index, (GLuint)x, (GLuint)y);
            }
            
            public static 
            void VertexAttribI3ui(Int32 index, Int32 x, Int32 y, Int32 z)
            {
                Delegates.glVertexAttribI3uiEXT((GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
            {
                Delegates.glVertexAttribI3uiEXT((GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z);
            }
            
            public static 
            void VertexAttribI4ui(Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glVertexAttribI4uiEXT((GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
            {
                Delegates.glVertexAttribI4uiEXT((GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI1iv(Int32 index, GLint* v)
            {
                    {
                        Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI1iv(GLuint index, GLint* v)
            {
                unsafe { Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v); }
            }
            
            public static 
            void VertexAttribI1iv(Int32 index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1iv(GLuint index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI1iv(Int32 index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1iv(GLuint index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI1ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI2iv(Int32 index, GLint* v)
            {
                    {
                        Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI2iv(GLuint index, GLint* v)
            {
                unsafe { Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v); }
            }
            
            public static 
            void VertexAttribI2iv(Int32 index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2iv(GLuint index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI2iv(Int32 index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2iv(GLuint index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI2ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI3iv(Int32 index, GLint* v)
            {
                    {
                        Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI3iv(GLuint index, GLint* v)
            {
                unsafe { Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v); }
            }
            
            public static 
            void VertexAttribI3iv(Int32 index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3iv(GLuint index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI3iv(Int32 index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3iv(GLuint index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI3ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4iv(Int32 index, GLint* v)
            {
                    {
                        Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4iv(GLuint index, GLint* v)
            {
                unsafe { Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v); }
            }
            
            public static 
            void VertexAttribI4iv(Int32 index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4iv(GLuint index, GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI4iv(Int32 index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4iv(GLuint index, ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4ivEXT((GLuint)index, (GLint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI1uiv(Int32 index, Int32* v)
            {
                    {
                        Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI1uiv(GLuint index, GLuint* v)
            {
                unsafe { Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v); }
            }
            
            public static 
            void VertexAttribI1uiv(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1uiv(GLuint index, GLuint[] v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI1uiv(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1uiv(GLuint index, ref GLuint v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI1uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI2uiv(Int32 index, Int32* v)
            {
                    {
                        Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI2uiv(GLuint index, GLuint* v)
            {
                unsafe { Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v); }
            }
            
            public static 
            void VertexAttribI2uiv(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2uiv(GLuint index, GLuint[] v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI2uiv(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2uiv(GLuint index, ref GLuint v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI2uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI3uiv(Int32 index, Int32* v)
            {
                    {
                        Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI3uiv(GLuint index, GLuint* v)
            {
                unsafe { Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v); }
            }
            
            public static 
            void VertexAttribI3uiv(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3uiv(GLuint index, GLuint[] v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI3uiv(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3uiv(GLuint index, ref GLuint v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI3uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4uiv(Int32 index, Int32* v)
            {
                    {
                        Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4uiv(GLuint index, GLuint* v)
            {
                unsafe { Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v); }
            }
            
            public static 
            void VertexAttribI4uiv(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4uiv(GLuint index, GLuint[] v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI4uiv(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4uiv(GLuint index, ref GLuint v)
            {
                unsafe
                {
                    fixed (GLuint* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4uivEXT((GLuint)index, (GLuint*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4bv(Int32 index, Byte* v)
            {
                    {
                        Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4bv(GLuint index, GLbyte* v)
            {
                unsafe { Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v); }
            }
            
            public static 
            void VertexAttribI4bv(Int32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4bv(GLuint index, GLbyte[] v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI4bv(Int32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4bv(GLuint index, ref GLbyte v)
            {
                unsafe
                {
                    fixed (GLbyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4bvEXT((GLuint)index, (GLbyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttribI4sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI4sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4svEXT((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4ubv(Int32 index, GLubyte* v)
            {
                    {
                        Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4ubv(GLuint index, GLubyte* v)
            {
                unsafe { Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v); }
            }
            
            public static 
            void VertexAttribI4ubv(Int32 index, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4ubv(GLuint index, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI4ubv(Int32 index, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4ubv(GLuint index, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4ubvEXT((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4usv(Int32 index, Int16* v)
            {
                    {
                        Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4usv(GLuint index, GLushort* v)
            {
                unsafe { Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v); }
            }
            
            public static 
            void VertexAttribI4usv(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4usv(GLuint index, GLushort[] v)
            {
                unsafe
                {
                    fixed (GLushort* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribI4usv(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4usv(GLuint index, ref GLushort v)
            {
                unsafe
                {
                    fixed (GLushort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4usvEXT((GLuint)index, (GLushort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribIPointer(Int32 index, GLint size, GL.Enums.NV_vertex_program4 type, GLsizei stride, void* pointer)
            {
                    {
                        Delegates.glVertexAttribIPointerEXT((GLuint)index, (GLint)size, (GL.Enums.NV_vertex_program4)type, (GLsizei)stride, (void*)pointer);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribIPointer(GLuint index, GLint size, GL.Enums.NV_vertex_program4 type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glVertexAttribIPointerEXT((GLuint)index, (GLint)size, (GL.Enums.NV_vertex_program4)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void VertexAttribIPointer(Int32 index, GLint size, GL.Enums.NV_vertex_program4 type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexAttribIPointerEXT((GLuint)index, (GLint)size, (GL.Enums.NV_vertex_program4)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribIPointer(GLuint index, GLint size, GL.Enums.NV_vertex_program4 type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexAttribIPointerEXT((GLuint)index, (GLint)size, (GL.Enums.NV_vertex_program4)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribIiv(Int32 index, GL.Enums.NV_vertex_program4 pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribIiv(GLuint index, GL.Enums.NV_vertex_program4 pname, GLint* @params)
            {
                unsafe { Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params); }
            }
            
            public static 
            void GetVertexAttribIiv(Int32 index, GL.Enums.NV_vertex_program4 pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribIiv(GLuint index, GL.Enums.NV_vertex_program4 pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribIiv(Int32 index, GL.Enums.NV_vertex_program4 pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribIiv(GLuint index, GL.Enums.NV_vertex_program4 pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribIivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribIuiv(Int32 index, GL.Enums.NV_vertex_program4 pname, Int32* @params)
            {
                @params = default(Int32*);
                    {
                        Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribIuiv(GLuint index, GL.Enums.NV_vertex_program4 pname, GLuint* @params)
            {
                unsafe { Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params); }
            }
            
            public static 
            void GetVertexAttribIuiv(Int32 index, GL.Enums.NV_vertex_program4 pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribIuiv(GLuint index, GL.Enums.NV_vertex_program4 pname, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribIuiv(Int32 index, GL.Enums.NV_vertex_program4 pname, out Int32 @params)
            {
                @params = default(Int32);
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribIuiv(GLuint index, GL.Enums.NV_vertex_program4 pname, out GLuint @params)
            {
                @params = default(GLuint);
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribIuivEXT((GLuint)index, (GL.Enums.NV_vertex_program4)pname, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniformuiv(Int32 program, GLint location, Int32* @params)
            {
                @params = default(Int32*);
                    {
                        Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniformuiv(GLuint program, GLint location, GLuint* @params)
            {
                unsafe { Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params); }
            }
            
            public static 
            void GetUniformuiv(Int32 program, GLint location, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetUniformuiv(GLuint program, GLint location, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetUniformuiv(Int32 program, GLint location, out Int32 @params)
            {
                @params = default(Int32);
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetUniformuiv(GLuint program, GLint location, out GLuint @params)
            {
                @params = default(GLuint);
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformuivEXT((GLuint)program, (GLint)location, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void BindFragDataLocation(Int32 program, Int32 color, System.String name)
            {
                Delegates.glBindFragDataLocationEXT((GLuint)program, (GLuint)color, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindFragDataLocation(GLuint program, GLuint color, System.String name)
            {
                Delegates.glBindFragDataLocationEXT((GLuint)program, (GLuint)color, (System.String)name);
            }
            
            public static 
            GLint GetFragDataLocation(Int32 program, System.String name)
            {
                return Delegates.glGetFragDataLocationEXT((GLuint)program, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint GetFragDataLocation(GLuint program, System.String name)
            {
                return Delegates.glGetFragDataLocationEXT((GLuint)program, (System.String)name);
            }
            
            public static 
            void Uniform1ui(GLint location, Int32 v0)
            {
                Delegates.glUniform1uiEXT((GLint)location, (GLuint)v0);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform1ui(GLint location, GLuint v0)
            {
                Delegates.glUniform1uiEXT((GLint)location, (GLuint)v0);
            }
            
            public static 
            void Uniform2ui(GLint location, Int32 v0, Int32 v1)
            {
                Delegates.glUniform2uiEXT((GLint)location, (GLuint)v0, (GLuint)v1);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform2ui(GLint location, GLuint v0, GLuint v1)
            {
                Delegates.glUniform2uiEXT((GLint)location, (GLuint)v0, (GLuint)v1);
            }
            
            public static 
            void Uniform3ui(GLint location, Int32 v0, Int32 v1, Int32 v2)
            {
                Delegates.glUniform3uiEXT((GLint)location, (GLuint)v0, (GLuint)v1, (GLuint)v2);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
            {
                Delegates.glUniform3uiEXT((GLint)location, (GLuint)v0, (GLuint)v1, (GLuint)v2);
            }
            
            public static 
            void Uniform4ui(GLint location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
            {
                Delegates.glUniform4uiEXT((GLint)location, (GLuint)v0, (GLuint)v1, (GLuint)v2, (GLuint)v3);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
            {
                Delegates.glUniform4uiEXT((GLint)location, (GLuint)v0, (GLuint)v1, (GLuint)v2, (GLuint)v3);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform1uiv(GLint location, GLsizei count, Int32* value)
            {
                    {
                        Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform1uiv(GLint location, GLsizei count, GLuint* value)
            {
                unsafe { Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value); }
            }
            
            public static 
            void Uniform1uiv(GLint location, GLsizei count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform1uiv(GLint location, GLsizei count, GLuint[] value)
            {
                unsafe
                {
                    fixed (GLuint* value_ptr = value)
                    {
                        Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform1uiv(GLint location, GLsizei count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform1uiv(GLint location, GLsizei count, ref GLuint value)
            {
                unsafe
                {
                    fixed (GLuint* value_ptr = &value)
                    {
                        Delegates.glUniform1uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform2uiv(GLint location, GLsizei count, Int32* value)
            {
                    {
                        Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform2uiv(GLint location, GLsizei count, GLuint* value)
            {
                unsafe { Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value); }
            }
            
            public static 
            void Uniform2uiv(GLint location, GLsizei count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform2uiv(GLint location, GLsizei count, GLuint[] value)
            {
                unsafe
                {
                    fixed (GLuint* value_ptr = value)
                    {
                        Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform2uiv(GLint location, GLsizei count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform2uiv(GLint location, GLsizei count, ref GLuint value)
            {
                unsafe
                {
                    fixed (GLuint* value_ptr = &value)
                    {
                        Delegates.glUniform2uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform3uiv(GLint location, GLsizei count, Int32* value)
            {
                    {
                        Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform3uiv(GLint location, GLsizei count, GLuint* value)
            {
                unsafe { Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value); }
            }
            
            public static 
            void Uniform3uiv(GLint location, GLsizei count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform3uiv(GLint location, GLsizei count, GLuint[] value)
            {
                unsafe
                {
                    fixed (GLuint* value_ptr = value)
                    {
                        Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform3uiv(GLint location, GLsizei count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform3uiv(GLint location, GLsizei count, ref GLuint value)
            {
                unsafe
                {
                    fixed (GLuint* value_ptr = &value)
                    {
                        Delegates.glUniform3uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform4uiv(GLint location, GLsizei count, Int32* value)
            {
                    {
                        Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform4uiv(GLint location, GLsizei count, GLuint* value)
            {
                unsafe { Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value); }
            }
            
            public static 
            void Uniform4uiv(GLint location, GLsizei count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform4uiv(GLint location, GLsizei count, GLuint[] value)
            {
                unsafe
                {
                    fixed (GLuint* value_ptr = value)
                    {
                        Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            public static 
            void Uniform4uiv(GLint location, GLsizei count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Uniform4uiv(GLint location, GLsizei count, ref GLuint value)
            {
                unsafe
                {
                    fixed (GLuint* value_ptr = &value)
                    {
                        Delegates.glUniform4uivEXT((GLint)location, (GLsizei)count, (GLuint*)value_ptr);
                    }
                }
            }
            
            public static 
            void DrawArraysInstanced(GL.Enums.BeginMode mode, GLint start, GLsizei count, GLsizei primcount)
            {
                Delegates.glDrawArraysInstancedEXT((GL.Enums.BeginMode)mode, (GLint)start, (GLsizei)count, (GLsizei)primcount);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DrawElementsInstanced(GL.Enums.BeginMode mode, GLsizei count, GL.Enums.EXT_draw_instanced type, void* indices, GLsizei primcount)
            {
                unsafe { Delegates.glDrawElementsInstancedEXT((GL.Enums.BeginMode)mode, (GLsizei)count, (GL.Enums.EXT_draw_instanced)type, (void*)indices, (GLsizei)primcount); }
            }
            
            public static 
            void DrawElementsInstanced(GL.Enums.BeginMode mode, GLsizei count, GL.Enums.EXT_draw_instanced type, object indices, GLsizei primcount)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glDrawElementsInstancedEXT((GL.Enums.BeginMode)mode, (GLsizei)count, (GL.Enums.EXT_draw_instanced)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            public static 
            void TexBuffer(GL.Enums.TextureTarget target, GL.Enums.EXT_texture_buffer_object internalformat, Int32 buffer)
            {
                Delegates.glTexBufferEXT((GL.Enums.TextureTarget)target, (GL.Enums.EXT_texture_buffer_object)internalformat, (GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexBuffer(GL.Enums.TextureTarget target, GL.Enums.EXT_texture_buffer_object internalformat, GLuint buffer)
            {
                Delegates.glTexBufferEXT((GL.Enums.TextureTarget)target, (GL.Enums.EXT_texture_buffer_object)internalformat, (GLuint)buffer);
            }
            
            public static 
            void ColorMaskIndexed(Int32 index, GL.Enums.Boolean r, GL.Enums.Boolean g, GL.Enums.Boolean b, GL.Enums.Boolean a)
            {
                unsafe
                {
                    {
                        Delegates.glColorMaskIndexedEXT((GLuint)index, (GL.Enums.Boolean)r, (GL.Enums.Boolean)g, (GL.Enums.Boolean)b, (GL.Enums.Boolean)a);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ColorMaskIndexed(GLuint index, GL.Enums.Boolean r, GL.Enums.Boolean g, GL.Enums.Boolean b, GL.Enums.Boolean a)
            {
                 Delegates.glColorMaskIndexedEXT((GLuint)index, (GL.Enums.Boolean)r, (GL.Enums.Boolean)g, (GL.Enums.Boolean)b, (GL.Enums.Boolean)a); 
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetBooleanIndexedv(GL.Enums.EXT_draw_buffers2 target, Int32 index, GL.Enums.Boolean* data)
            {
                data = default(GL.Enums.Boolean*);
                    {
                        Delegates.glGetBooleanIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GL.Enums.Boolean*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetBooleanIndexedv(GL.Enums.EXT_draw_buffers2 target, GLuint index, GL.Enums.Boolean* data)
            {
                unsafe { Delegates.glGetBooleanIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GL.Enums.Boolean*)data); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, Int32 index, GLint* data)
            {
                data = default(GLint*);
                    {
                        Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, GLuint index, GLint* data)
            {
                unsafe { Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data); }
            }
            
            public static 
            void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, Int32 index, GLint[] data)
            {
                unsafe
                {
                    fixed (GLint* data_ptr = data)
                    {
                        Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, GLuint index, GLint[] data)
            {
                unsafe
                {
                    fixed (GLint* data_ptr = data)
                    {
                        Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data_ptr);
                    }
                }
            }
            
            public static 
            void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, Int32 index, out GLint data)
            {
                data = default(GLint);
                unsafe
                {
                    fixed (GLint* data_ptr = &data)
                    {
                        Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetIntegerIndexedv(GL.Enums.EXT_draw_buffers2 target, GLuint index, out GLint data)
            {
                data = default(GLint);
                unsafe
                {
                    fixed (GLint* data_ptr = &data)
                    {
                        Delegates.glGetIntegerIndexedvEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index, (GLint*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }
            
            public static 
            void EnableIndexed(GL.Enums.EXT_draw_buffers2 target, Int32 index)
            {
                Delegates.glEnableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void EnableIndexed(GL.Enums.EXT_draw_buffers2 target, GLuint index)
            {
                Delegates.glEnableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
            }
            
            public static 
            void DisableIndexed(GL.Enums.EXT_draw_buffers2 target, Int32 index)
            {
                Delegates.glDisableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DisableIndexed(GL.Enums.EXT_draw_buffers2 target, GLuint index)
            {
                Delegates.glDisableIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
            }
            
            public static 
            GLboolean IsEnabledIndexed(GL.Enums.EXT_draw_buffers2 target, Int32 index)
            {
                return Delegates.glIsEnabledIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsEnabledIndexed(GL.Enums.EXT_draw_buffers2 target, GLuint index)
            {
                return Delegates.glIsEnabledIndexedEXT((GL.Enums.EXT_draw_buffers2)target, (GLuint)index);
            }
            
            public static 
            void UniformBuffer(Int32 program, GLint location, Int32 buffer)
            {
                Delegates.glUniformBufferEXT((GLuint)program, (GLint)location, (GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void UniformBuffer(GLuint program, GLint location, GLuint buffer)
            {
                Delegates.glUniformBufferEXT((GLuint)program, (GLint)location, (GLuint)buffer);
            }
            
            public static 
            GLint GetUniformBufferSize(Int32 program, GLint location)
            {
                return Delegates.glGetUniformBufferSizeEXT((GLuint)program, (GLint)location);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint GetUniformBufferSize(GLuint program, GLint location)
            {
                return Delegates.glGetUniformBufferSizeEXT((GLuint)program, (GLint)location);
            }
            
            public static 
            GLintptr GetUniformOffset(Int32 program, GLint location)
            {
                return Delegates.glGetUniformOffsetEXT((GLuint)program, (GLint)location);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLintptr GetUniformOffset(GLuint program, GLint location)
            {
                return Delegates.glGetUniformOffsetEXT((GLuint)program, (GLint)location);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint* @params)
            {
                unsafe { Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params); }
            }
            
            public static 
            void TexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void TexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, Int32* @params)
            {
                    {
                        Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLuint* @params)
            {
                unsafe { Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params); }
            }
            
            public static 
            void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.TextureParameterName pname, ref GLuint @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.TextureParameterName)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLint* @params)
            {
                unsafe { Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params); }
            }
            
            public static 
            void GetTexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetTexParameterIiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetTexParameterIivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, Int32* @params)
            {
                @params = default(Int32*);
                    {
                        Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLuint* @params)
            {
                unsafe { Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params); }
            }
            
            public static 
            void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out Int32 @params)
            {
                @params = default(Int32);
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetTexParameterIuiv(GL.Enums.TextureTarget target, GL.Enums.GetTextureParameter pname, out GLuint @params)
            {
                @params = default(GLuint);
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glGetTexParameterIuivEXT((GL.Enums.TextureTarget)target, (GL.Enums.GetTextureParameter)pname, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void ClearColorIi(GLint red, GLint green, GLint blue, GLint alpha)
            {
                Delegates.glClearColorIiEXT((GLint)red, (GLint)green, (GLint)blue, (GLint)alpha);
            }
            
            public static 
            void ClearColorIui(Int32 red, Int32 green, Int32 blue, Int32 alpha)
            {
                Delegates.glClearColorIuiEXT((GLuint)red, (GLuint)green, (GLuint)blue, (GLuint)alpha);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ClearColorIui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
            {
                Delegates.glClearColorIuiEXT((GLuint)red, (GLuint)green, (GLuint)blue, (GLuint)alpha);
            }
            
        }

        public static class SGIS
        {
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLfloat* weights)
            {
                unsafe { Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLfloat*)weights); }
            }
            
            public static 
            void GetTexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLfloat[] weights)
            {
                unsafe
                {
                    fixed (GLfloat* weights_ptr = weights)
                    {
                        Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLfloat*)weights_ptr);
                    }
                }
            }
            
            public static 
            void GetTexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, out GLfloat weights)
            {
                weights = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* weights_ptr = &weights)
                    {
                        Delegates.glGetTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLfloat*)weights_ptr);
                        weights = *weights_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLsizei n, GLfloat* weights)
            {
                unsafe { Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLsizei)n, (GLfloat*)weights); }
            }
            
            public static 
            void TexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLsizei n, GLfloat[] weights)
            {
                unsafe
                {
                    fixed (GLfloat* weights_ptr = weights)
                    {
                        Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLsizei)n, (GLfloat*)weights_ptr);
                    }
                }
            }
            
            public static 
            void TexFilterFunc(GL.Enums.TextureTarget target, GL.Enums.SGIS_texture_filter4 filter, GLsizei n, ref GLfloat weights)
            {
                unsafe
                {
                    fixed (GLfloat* weights_ptr = &weights)
                    {
                        Delegates.glTexFilterFuncSGIS((GL.Enums.TextureTarget)target, (GL.Enums.SGIS_texture_filter4)filter, (GLsizei)n, (GLfloat*)weights_ptr);
                    }
                }
            }
            
            public static 
            void PixelTexGenParameteri(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint param)
            {
                Delegates.glPixelTexGenParameteriSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint* @params)
            {
                unsafe { Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params); }
            }
            
            public static 
            void PixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PixelTexGenParameterf(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat param)
            {
                Delegates.glPixelTexGenParameterfSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat* @params)
            {
                unsafe { Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params); }
            }
            
            public static 
            void PixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetPixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint* @params)
            {
                unsafe { Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params); }
            }
            
            public static 
            void GetPixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetPixelTexGenParameteriv(GL.Enums.PixelTexGenParameterNameSGIS pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetPixelTexGenParameterivSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetPixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetPixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetPixelTexGenParameterfv(GL.Enums.PixelTexGenParameterNameSGIS pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetPixelTexGenParameterfvSGIS((GL.Enums.PixelTexGenParameterNameSGIS)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexImage4D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
            {
                unsafe { Delegates.glTexImage4DSGIS((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLsizei)size4d, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
            }
            
            public static 
            void TexImage4D(GL.Enums.TextureTarget target, GLint level, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTexImage4DSGIS((GL.Enums.TextureTarget)target, (GLint)level, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLsizei)size4d, (GLint)border, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pixels_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexSubImage4D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* pixels)
            {
                unsafe { Delegates.glTexSubImage4DSGIS((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLint)woffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLsizei)size4d, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels); }
            }
            
            public static 
            void TexSubImage4D(GL.Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTexSubImage4DSGIS((GL.Enums.TextureTarget)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLint)zoffset, (GLint)woffset, (GLsizei)width, (GLsizei)height, (GLsizei)depth, (GLsizei)size4d, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)pixels_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pixels_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DetailTexFunc(GL.Enums.TextureTarget target, GLsizei n, GLfloat* points)
            {
                unsafe { Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points); }
            }
            
            public static 
            void DetailTexFunc(GL.Enums.TextureTarget target, GLsizei n, GLfloat[] points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = points)
                    {
                        Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points_ptr);
                    }
                }
            }
            
            public static 
            void DetailTexFunc(GL.Enums.TextureTarget target, GLsizei n, ref GLfloat points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = &points)
                    {
                        Delegates.glDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetDetailTexFunc(GL.Enums.TextureTarget target, GLfloat* points)
            {
                unsafe { Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points); }
            }
            
            public static 
            void GetDetailTexFunc(GL.Enums.TextureTarget target, GLfloat[] points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = points)
                    {
                        Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points_ptr);
                    }
                }
            }
            
            public static 
            void GetDetailTexFunc(GL.Enums.TextureTarget target, out GLfloat points)
            {
                points = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* points_ptr = &points)
                    {
                        Delegates.glGetDetailTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points_ptr);
                        points = *points_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SharpenTexFunc(GL.Enums.TextureTarget target, GLsizei n, GLfloat* points)
            {
                unsafe { Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points); }
            }
            
            public static 
            void SharpenTexFunc(GL.Enums.TextureTarget target, GLsizei n, GLfloat[] points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = points)
                    {
                        Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points_ptr);
                    }
                }
            }
            
            public static 
            void SharpenTexFunc(GL.Enums.TextureTarget target, GLsizei n, ref GLfloat points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = &points)
                    {
                        Delegates.glSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLsizei)n, (GLfloat*)points_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSharpenTexFunc(GL.Enums.TextureTarget target, GLfloat* points)
            {
                unsafe { Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points); }
            }
            
            public static 
            void GetSharpenTexFunc(GL.Enums.TextureTarget target, GLfloat[] points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = points)
                    {
                        Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points_ptr);
                    }
                }
            }
            
            public static 
            void GetSharpenTexFunc(GL.Enums.TextureTarget target, out GLfloat points)
            {
                points = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* points_ptr = &points)
                    {
                        Delegates.glGetSharpenTexFuncSGIS((GL.Enums.TextureTarget)target, (GLfloat*)points_ptr);
                        points = *points_ptr;
                    }
                }
            }
            
            public static 
            void SampleMask(GLclampf value, GL.Enums.Boolean invert)
            {
                 Delegates.glSampleMaskSGIS((GLclampf)value, (GL.Enums.Boolean)invert); 
            }
            
            public static 
            void SamplePattern(GL.Enums.SamplePatternSGIS pattern)
            {
                Delegates.glSamplePatternSGIS((GL.Enums.SamplePatternSGIS)pattern);
            }
            
            public static 
            void PointParameterf(GL.Enums.SGIS_point_parameters pname, GLfloat param)
            {
                Delegates.glPointParameterfSGIS((GL.Enums.SGIS_point_parameters)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PointParameterfv(GL.Enums.SGIS_point_parameters pname, GLfloat* @params)
            {
                unsafe { Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (GLfloat*)@params); }
            }
            
            public static 
            void PointParameterfv(GL.Enums.SGIS_point_parameters pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PointParameterfv(GL.Enums.SGIS_point_parameters pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glPointParameterfvSGIS((GL.Enums.SGIS_point_parameters)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FogFunc(GLsizei n, GLfloat* points)
            {
                unsafe { Delegates.glFogFuncSGIS((GLsizei)n, (GLfloat*)points); }
            }
            
            public static 
            void FogFunc(GLsizei n, GLfloat[] points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = points)
                    {
                        Delegates.glFogFuncSGIS((GLsizei)n, (GLfloat*)points_ptr);
                    }
                }
            }
            
            public static 
            void FogFunc(GLsizei n, ref GLfloat points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = &points)
                    {
                        Delegates.glFogFuncSGIS((GLsizei)n, (GLfloat*)points_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFogFunc(GLfloat* points)
            {
                unsafe { Delegates.glGetFogFuncSGIS((GLfloat*)points); }
            }
            
            public static 
            void GetFogFunc(GLfloat[] points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = points)
                    {
                        Delegates.glGetFogFuncSGIS((GLfloat*)points_ptr);
                    }
                }
            }
            
            public static 
            void GetFogFunc(out GLfloat points)
            {
                points = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* points_ptr = &points)
                    {
                        Delegates.glGetFogFuncSGIS((GLfloat*)points_ptr);
                        points = *points_ptr;
                    }
                }
            }
            
            public static 
            void TextureColorMask(GL.Enums.Boolean red, GL.Enums.Boolean green, GL.Enums.Boolean blue, GL.Enums.Boolean alpha)
            {
                 Delegates.glTextureColorMaskSGIS((GL.Enums.Boolean)red, (GL.Enums.Boolean)green, (GL.Enums.Boolean)blue, (GL.Enums.Boolean)alpha); 
            }
            
        }

        public static class SGI
        {
            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
            {
                unsafe { Delegates.glColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
            }
            
            public static 
            void ColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        table_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, GLfloat* @params)
            {
                unsafe { Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLfloat*)@params); }
            }
            
            public static 
            void ColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, GLint* @params)
            {
                unsafe { Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLint*)@params); }
            }
            
            public static 
            void ColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.ColorTableParameterPNameSGI pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.ColorTableParameterPNameSGI)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CopyColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
            {
                Delegates.glCopyColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelInternalFormat)internalformat, (GLint)x, (GLint)y, (GLsizei)width);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, void* table)
            {
                unsafe { Delegates.glGetColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table); }
            }
            
            public static 
            void GetColorTable(GL.Enums.ColorTableTargetSGI target, GL.Enums.PixelFormat format, GL.Enums.PixelType type, object table)
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetColorTableSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.PixelFormat)format, (GL.Enums.PixelType)type, (void*)table_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        table_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetColorTableParameterfv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetColorTableParameterfvSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, GLint* @params)
            {
                unsafe { Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLint*)@params); }
            }
            
            public static 
            void GetColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetColorTableParameteriv(GL.Enums.ColorTableTargetSGI target, GL.Enums.GetColorTableParameterPNameSGI pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetColorTableParameterivSGI((GL.Enums.ColorTableTargetSGI)target, (GL.Enums.GetColorTableParameterPNameSGI)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
        }

        public static class SGIX
        {
            public static 
            void PixelTexGen(GL.Enums.SGIX_pixel_texture mode)
            {
                Delegates.glPixelTexGenSGIX((GL.Enums.SGIX_pixel_texture)mode);
            }
            
            public static 
            void SpriteParameterf(GL.Enums.SGIX_sprite pname, GLfloat param)
            {
                Delegates.glSpriteParameterfSGIX((GL.Enums.SGIX_sprite)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SpriteParameterfv(GL.Enums.SGIX_sprite pname, GLfloat* @params)
            {
                unsafe { Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (GLfloat*)@params); }
            }
            
            public static 
            void SpriteParameterfv(GL.Enums.SGIX_sprite pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void SpriteParameterfv(GL.Enums.SGIX_sprite pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glSpriteParameterfvSGIX((GL.Enums.SGIX_sprite)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void SpriteParameteri(GL.Enums.SGIX_sprite pname, GLint param)
            {
                Delegates.glSpriteParameteriSGIX((GL.Enums.SGIX_sprite)pname, (GLint)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SpriteParameteriv(GL.Enums.SGIX_sprite pname, GLint* @params)
            {
                unsafe { Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (GLint*)@params); }
            }
            
            public static 
            void SpriteParameteriv(GL.Enums.SGIX_sprite pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void SpriteParameteriv(GL.Enums.SGIX_sprite pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glSpriteParameterivSGIX((GL.Enums.SGIX_sprite)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            GLint GetInstruments()
            {
                return Delegates.glGetInstrumentsSGIX();
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void InstrumentsBuffer(GLsizei size, GLint* buffer)
            {
                unsafe { Delegates.glInstrumentsBufferSGIX((GLsizei)size, (GLint*)buffer); }
            }
            
            public static 
            void InstrumentsBuffer(GLsizei size, GLint[] buffer)
            {
                unsafe
                {
                    fixed (GLint* buffer_ptr = buffer)
                    {
                        Delegates.glInstrumentsBufferSGIX((GLsizei)size, (GLint*)buffer_ptr);
                    }
                }
            }
            
            public static 
            void InstrumentsBuffer(GLsizei size, out GLint buffer)
            {
                buffer = default(GLint);
                unsafe
                {
                    fixed (GLint* buffer_ptr = &buffer)
                    {
                        Delegates.glInstrumentsBufferSGIX((GLsizei)size, (GLint*)buffer_ptr);
                        buffer = *buffer_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLint PollInstruments(GLint* marker_p)
            {
                unsafe { return Delegates.glPollInstrumentsSGIX((GLint*)marker_p); }
            }
            
            public static 
            GLint PollInstruments(GLint[] marker_p)
            {
                unsafe
                {
                    fixed (GLint* marker_p_ptr = marker_p)
                    {
                        GLint retval = Delegates.glPollInstrumentsSGIX((GLint*)marker_p_ptr);
                        return retval;
                    }
                }
            }
            
            public static 
            GLint PollInstruments(out GLint marker_p)
            {
                marker_p = default(GLint);
                unsafe
                {
                    fixed (GLint* marker_p_ptr = &marker_p)
                    {
                        GLint retval = Delegates.glPollInstrumentsSGIX((GLint*)marker_p_ptr);
                        marker_p = *marker_p_ptr;
                        return retval;
                    }
                }
            }
            
            public static 
            void ReadInstruments(GLint marker)
            {
                Delegates.glReadInstrumentsSGIX((GLint)marker);
            }
            
            public static 
            void StartInstruments()
            {
                Delegates.glStartInstrumentsSGIX();
            }
            
            public static 
            void StopInstruments(GLint marker)
            {
                Delegates.glStopInstrumentsSGIX((GLint)marker);
            }
            
            public static 
            void FrameZoom(GLint factor)
            {
                Delegates.glFrameZoomSGIX((GLint)factor);
            }
            
            public static 
            void TagSampleBuffer()
            {
                Delegates.glTagSampleBufferSGIX();
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeformationMap3d(GL.Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble* points)
            {
                unsafe { Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble)w1, (GLdouble)w2, (GLint)wstride, (GLint)worder, (GLdouble*)points); }
            }
            
            public static 
            void DeformationMap3d(GL.Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble[] points)
            {
                unsafe
                {
                    fixed (GLdouble* points_ptr = points)
                    {
                        Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble)w1, (GLdouble)w2, (GLint)wstride, (GLint)worder, (GLdouble*)points_ptr);
                    }
                }
            }
            
            public static 
            void DeformationMap3d(GL.Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, ref GLdouble points)
            {
                unsafe
                {
                    fixed (GLdouble* points_ptr = &points)
                    {
                        Delegates.glDeformationMap3dSGIX((GL.Enums.FfdTargetSGIX)target, (GLdouble)u1, (GLdouble)u2, (GLint)ustride, (GLint)uorder, (GLdouble)v1, (GLdouble)v2, (GLint)vstride, (GLint)vorder, (GLdouble)w1, (GLdouble)w2, (GLint)wstride, (GLint)worder, (GLdouble*)points_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeformationMap3f(GL.Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat* points)
            {
                unsafe { Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat)w1, (GLfloat)w2, (GLint)wstride, (GLint)worder, (GLfloat*)points); }
            }
            
            public static 
            void DeformationMap3f(GL.Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat[] points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = points)
                    {
                        Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat)w1, (GLfloat)w2, (GLint)wstride, (GLint)worder, (GLfloat*)points_ptr);
                    }
                }
            }
            
            public static 
            void DeformationMap3f(GL.Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, ref GLfloat points)
            {
                unsafe
                {
                    fixed (GLfloat* points_ptr = &points)
                    {
                        Delegates.glDeformationMap3fSGIX((GL.Enums.FfdTargetSGIX)target, (GLfloat)u1, (GLfloat)u2, (GLint)ustride, (GLint)uorder, (GLfloat)v1, (GLfloat)v2, (GLint)vstride, (GLint)vorder, (GLfloat)w1, (GLfloat)w2, (GLint)wstride, (GLint)worder, (GLfloat*)points_ptr);
                    }
                }
            }
            
            public static 
            void Deform(GL.Enums.FfdMaskSGIX mask)
            {
                Delegates.glDeformSGIX((GL.Enums.FfdMaskSGIX)mask);
            }
            
            public static 
            void LoadIdentityDeformationMap(GL.Enums.FfdMaskSGIX mask)
            {
                Delegates.glLoadIdentityDeformationMapSGIX((GL.Enums.FfdMaskSGIX)mask);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReferencePlane(GLdouble* equation)
            {
                unsafe { Delegates.glReferencePlaneSGIX((GLdouble*)equation); }
            }
            
            public static 
            void ReferencePlane(GLdouble[] equation)
            {
                unsafe
                {
                    fixed (GLdouble* equation_ptr = equation)
                    {
                        Delegates.glReferencePlaneSGIX((GLdouble*)equation_ptr);
                    }
                }
            }
            
            public static 
            void ReferencePlane(ref GLdouble equation)
            {
                unsafe
                {
                    fixed (GLdouble* equation_ptr = &equation)
                    {
                        Delegates.glReferencePlaneSGIX((GLdouble*)equation_ptr);
                    }
                }
            }
            
            public static 
            void FlushRaster()
            {
                Delegates.glFlushRasterSGIX();
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetListParameterfv(Int32 list, GL.Enums.ListParameterName pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetListParameterfv(GLuint list, GL.Enums.ListParameterName pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetListParameterfv(Int32 list, GL.Enums.ListParameterName pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetListParameterfv(GLuint list, GL.Enums.ListParameterName pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetListParameterfv(Int32 list, GL.Enums.ListParameterName pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetListParameterfv(GLuint list, GL.Enums.ListParameterName pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetListParameteriv(Int32 list, GL.Enums.ListParameterName pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetListParameteriv(GLuint list, GL.Enums.ListParameterName pname, GLint* @params)
            {
                unsafe { Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params); }
            }
            
            public static 
            void GetListParameteriv(Int32 list, GL.Enums.ListParameterName pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetListParameteriv(GLuint list, GL.Enums.ListParameterName pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetListParameteriv(Int32 list, GL.Enums.ListParameterName pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetListParameteriv(GLuint list, GL.Enums.ListParameterName pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void ListParameterf(Int32 list, GL.Enums.ListParameterName pname, GLfloat param)
            {
                Delegates.glListParameterfSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ListParameterf(GLuint list, GL.Enums.ListParameterName pname, GLfloat param)
            {
                Delegates.glListParameterfSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ListParameterfv(Int32 list, GL.Enums.ListParameterName pname, GLfloat* @params)
            {
                    {
                        Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ListParameterfv(GLuint list, GL.Enums.ListParameterName pname, GLfloat* @params)
            {
                unsafe { Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params); }
            }
            
            public static 
            void ListParameterfv(Int32 list, GL.Enums.ListParameterName pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ListParameterfv(GLuint list, GL.Enums.ListParameterName pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ListParameterfv(Int32 list, GL.Enums.ListParameterName pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ListParameterfv(GLuint list, GL.Enums.ListParameterName pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glListParameterfvSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ListParameteri(Int32 list, GL.Enums.ListParameterName pname, GLint param)
            {
                Delegates.glListParameteriSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ListParameteri(GLuint list, GL.Enums.ListParameterName pname, GLint param)
            {
                Delegates.glListParameteriSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ListParameteriv(Int32 list, GL.Enums.ListParameterName pname, GLint* @params)
            {
                    {
                        Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ListParameteriv(GLuint list, GL.Enums.ListParameterName pname, GLint* @params)
            {
                unsafe { Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params); }
            }
            
            public static 
            void ListParameteriv(Int32 list, GL.Enums.ListParameterName pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ListParameteriv(GLuint list, GL.Enums.ListParameterName pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ListParameteriv(Int32 list, GL.Enums.ListParameterName pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ListParameteriv(GLuint list, GL.Enums.ListParameterName pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glListParameterivSGIX((GLuint)list, (GL.Enums.ListParameterName)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentColorMaterial(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter mode)
            {
                Delegates.glFragmentColorMaterialSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)mode);
            }
            
            public static 
            void FragmentLightf(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat param)
            {
                Delegates.glFragmentLightfSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat* @params)
            {
                unsafe { Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params); }
            }
            
            public static 
            void FragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentLighti(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint param)
            {
                Delegates.glFragmentLightiSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint* @params)
            {
                unsafe { Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params); }
            }
            
            public static 
            void FragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentLightModelf(GL.Enums.FragmentLightModelParameterSGIX pname, GLfloat param)
            {
                Delegates.glFragmentLightModelfSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentLightModelfv(GL.Enums.FragmentLightModelParameterSGIX pname, GLfloat* @params)
            {
                unsafe { Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLfloat*)@params); }
            }
            
            public static 
            void FragmentLightModelfv(GL.Enums.FragmentLightModelParameterSGIX pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentLightModelfv(GL.Enums.FragmentLightModelParameterSGIX pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glFragmentLightModelfvSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentLightModeli(GL.Enums.FragmentLightModelParameterSGIX pname, GLint param)
            {
                Delegates.glFragmentLightModeliSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLint)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentLightModeliv(GL.Enums.FragmentLightModelParameterSGIX pname, GLint* @params)
            {
                unsafe { Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLint*)@params); }
            }
            
            public static 
            void FragmentLightModeliv(GL.Enums.FragmentLightModelParameterSGIX pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentLightModeliv(GL.Enums.FragmentLightModelParameterSGIX pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glFragmentLightModelivSGIX((GL.Enums.FragmentLightModelParameterSGIX)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentMaterialf(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat param)
            {
                Delegates.glFragmentMaterialfSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat* @params)
            {
                unsafe { Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params); }
            }
            
            public static 
            void FragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentMateriali(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint param)
            {
                Delegates.glFragmentMaterialiSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint* @params)
            {
                unsafe { Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params); }
            }
            
            public static 
            void FragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void FragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetFragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetFragmentLightfv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetFragmentLightfvSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint* @params)
            {
                unsafe { Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params); }
            }
            
            public static 
            void GetFragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetFragmentLightiv(GL.Enums.SGIX_fragment_lighting light, GL.Enums.SGIX_fragment_lighting pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetFragmentLightivSGIX((GL.Enums.SGIX_fragment_lighting)light, (GL.Enums.SGIX_fragment_lighting)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetFragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetFragmentMaterialfv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetFragmentMaterialfvSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint* @params)
            {
                unsafe { Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params); }
            }
            
            public static 
            void GetFragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetFragmentMaterialiv(GL.Enums.MaterialFace face, GL.Enums.MaterialParameter pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetFragmentMaterialivSGIX((GL.Enums.MaterialFace)face, (GL.Enums.MaterialParameter)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void LightEnvi(GL.Enums.LightEnvParameterSGIX pname, GLint param)
            {
                Delegates.glLightEnviSGIX((GL.Enums.LightEnvParameterSGIX)pname, (GLint)param);
            }
            
            public static 
            void AsyncMarker(Int32 marker)
            {
                Delegates.glAsyncMarkerSGIX((GLuint)marker);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void AsyncMarker(GLuint marker)
            {
                Delegates.glAsyncMarkerSGIX((GLuint)marker);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLint FinishAsync(Int32* markerp)
            {
                markerp = default(Int32*);
                    {
                        GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLint FinishAsync(GLuint* markerp)
            {
                unsafe { return Delegates.glFinishAsyncSGIX((GLuint*)markerp); }
            }
            
            public static 
            GLint FinishAsync(Int32[] markerp)
            {
                unsafe
                {
                    fixed (Int32* markerp_ptr = markerp)
                    {
                        GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp_ptr);
                        return retval;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint FinishAsync(GLuint[] markerp)
            {
                unsafe
                {
                    fixed (GLuint* markerp_ptr = markerp)
                    {
                        GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp_ptr);
                        return retval;
                    }
                }
            }
            
            public static 
            GLint FinishAsync(out Int32 markerp)
            {
                markerp = default(Int32);
                unsafe
                {
                    fixed (Int32* markerp_ptr = &markerp)
                    {
                        GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp_ptr);
                        markerp = *markerp_ptr;
                        return retval;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint FinishAsync(out GLuint markerp)
            {
                markerp = default(GLuint);
                unsafe
                {
                    fixed (GLuint* markerp_ptr = &markerp)
                    {
                        GLint retval = Delegates.glFinishAsyncSGIX((GLuint*)markerp_ptr);
                        markerp = *markerp_ptr;
                        return retval;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLint PollAsync(Int32* markerp)
            {
                markerp = default(Int32*);
                    {
                        GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLint PollAsync(GLuint* markerp)
            {
                unsafe { return Delegates.glPollAsyncSGIX((GLuint*)markerp); }
            }
            
            public static 
            GLint PollAsync(Int32[] markerp)
            {
                unsafe
                {
                    fixed (Int32* markerp_ptr = markerp)
                    {
                        GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp_ptr);
                        return retval;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint PollAsync(GLuint[] markerp)
            {
                unsafe
                {
                    fixed (GLuint* markerp_ptr = markerp)
                    {
                        GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp_ptr);
                        return retval;
                    }
                }
            }
            
            public static 
            GLint PollAsync(out Int32 markerp)
            {
                markerp = default(Int32);
                unsafe
                {
                    fixed (Int32* markerp_ptr = &markerp)
                    {
                        GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp_ptr);
                        markerp = *markerp_ptr;
                        return retval;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint PollAsync(out GLuint markerp)
            {
                markerp = default(GLuint);
                unsafe
                {
                    fixed (GLuint* markerp_ptr = &markerp)
                    {
                        GLint retval = Delegates.glPollAsyncSGIX((GLuint*)markerp_ptr);
                        markerp = *markerp_ptr;
                        return retval;
                    }
                }
            }
            
            public static 
            Int32 GenAsyncMarkers(GLsizei range)
            {
                return Delegates.glGenAsyncMarkersSGIX((GLsizei)range);
            }
            
            public static 
            void DeleteAsyncMarkers(Int32 marker, GLsizei range)
            {
                Delegates.glDeleteAsyncMarkersSGIX((GLuint)marker, (GLsizei)range);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteAsyncMarkers(GLuint marker, GLsizei range)
            {
                Delegates.glDeleteAsyncMarkersSGIX((GLuint)marker, (GLsizei)range);
            }
            
            public static 
            GLboolean IsAsyncMarker(Int32 marker)
            {
                return Delegates.glIsAsyncMarkerSGIX((GLuint)marker);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsAsyncMarker(GLuint marker)
            {
                return Delegates.glIsAsyncMarkerSGIX((GLuint)marker);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void IglooInterface(GL.Enums.GLenum pname, void* @params)
            {
                unsafe { Delegates.glIglooInterfaceSGIX((GL.Enums.GLenum)pname, (void*)@params); }
            }
            
            public static 
            void IglooInterface(GL.Enums.GLenum pname, object @params)
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glIglooInterfaceSGIX((GL.Enums.GLenum)pname, (void*)@params_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        @params_ptr.Free();
                    }
                }
            }
            
        }

        public static class HP
        {
            public static 
            void ImageTransformParameteri(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint param)
            {
                Delegates.glImageTransformParameteriHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint)param);
            }
            
            public static 
            void ImageTransformParameterf(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat param)
            {
                Delegates.glImageTransformParameterfHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint* @params)
            {
                unsafe { Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params); }
            }
            
            public static 
            void ImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat* @params)
            {
                unsafe { Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params); }
            }
            
            public static 
            void ImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint* @params)
            {
                unsafe { Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params); }
            }
            
            public static 
            void GetImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetImageTransformParameteriv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetImageTransformParameterivHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetImageTransformParameterfv(GL.Enums.HP_image_transform target, GL.Enums.HP_image_transform pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetImageTransformParameterfvHP((GL.Enums.HP_image_transform)target, (GL.Enums.HP_image_transform)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
        }

        public static class PGI
        {
            public static 
            void Hint(GL.Enums.PGI_misc_hints target, GLint mode)
            {
                Delegates.glHintPGI((GL.Enums.PGI_misc_hints)target, (GLint)mode);
            }
            
        }

        public static class SUNX
        {
            public static 
            void FinishTexture()
            {
                Delegates.glFinishTextureSUNX();
            }
            
        }

        public static class SUN
        {
            public static 
            void GlobalAlphaFactorb(Byte factor)
            {
                Delegates.glGlobalAlphaFactorbSUN((GLbyte)factor);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GlobalAlphaFactorb(GLbyte factor)
            {
                Delegates.glGlobalAlphaFactorbSUN((GLbyte)factor);
            }
            
            public static 
            void GlobalAlphaFactors(GLshort factor)
            {
                Delegates.glGlobalAlphaFactorsSUN((GLshort)factor);
            }
            
            public static 
            void GlobalAlphaFactori(GLint factor)
            {
                Delegates.glGlobalAlphaFactoriSUN((GLint)factor);
            }
            
            public static 
            void GlobalAlphaFactorf(GLfloat factor)
            {
                Delegates.glGlobalAlphaFactorfSUN((GLfloat)factor);
            }
            
            public static 
            void GlobalAlphaFactord(GLdouble factor)
            {
                Delegates.glGlobalAlphaFactordSUN((GLdouble)factor);
            }
            
            public static 
            void GlobalAlphaFactorub(GLubyte factor)
            {
                Delegates.glGlobalAlphaFactorubSUN((GLubyte)factor);
            }
            
            public static 
            void GlobalAlphaFactorus(Int16 factor)
            {
                Delegates.glGlobalAlphaFactorusSUN((GLushort)factor);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GlobalAlphaFactorus(GLushort factor)
            {
                Delegates.glGlobalAlphaFactorusSUN((GLushort)factor);
            }
            
            public static 
            void GlobalAlphaFactorui(Int32 factor)
            {
                Delegates.glGlobalAlphaFactoruiSUN((GLuint)factor);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GlobalAlphaFactorui(GLuint factor)
            {
                Delegates.glGlobalAlphaFactoruiSUN((GLuint)factor);
            }
            
            public static 
            void ReplacementCodeui(Int32 code)
            {
                Delegates.glReplacementCodeuiSUN((GLuint)code);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeui(GLuint code)
            {
                Delegates.glReplacementCodeuiSUN((GLuint)code);
            }
            
            public static 
            void ReplacementCodeus(Int16 code)
            {
                Delegates.glReplacementCodeusSUN((GLushort)code);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeus(GLushort code)
            {
                Delegates.glReplacementCodeusSUN((GLushort)code);
            }
            
            public static 
            void ReplacementCodeub(GLubyte code)
            {
                Delegates.glReplacementCodeubSUN((GLubyte)code);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiv(Int32* code)
            {
                    {
                        Delegates.glReplacementCodeuivSUN((GLuint*)code);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiv(GLuint* code)
            {
                unsafe { Delegates.glReplacementCodeuivSUN((GLuint*)code); }
            }
            
            public static 
            void ReplacementCodeuiv(Int32[] code)
            {
                unsafe
                {
                    fixed (Int32* code_ptr = code)
                    {
                        Delegates.glReplacementCodeuivSUN((GLuint*)code_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiv(GLuint[] code)
            {
                unsafe
                {
                    fixed (GLuint* code_ptr = code)
                    {
                        Delegates.glReplacementCodeuivSUN((GLuint*)code_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiv(ref Int32 code)
            {
                unsafe
                {
                    fixed (Int32* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeuivSUN((GLuint*)code_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiv(ref GLuint code)
            {
                unsafe
                {
                    fixed (GLuint* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeuivSUN((GLuint*)code_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeusv(Int16* code)
            {
                    {
                        Delegates.glReplacementCodeusvSUN((GLushort*)code);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeusv(GLushort* code)
            {
                unsafe { Delegates.glReplacementCodeusvSUN((GLushort*)code); }
            }
            
            public static 
            void ReplacementCodeusv(Int16[] code)
            {
                unsafe
                {
                    fixed (Int16* code_ptr = code)
                    {
                        Delegates.glReplacementCodeusvSUN((GLushort*)code_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeusv(GLushort[] code)
            {
                unsafe
                {
                    fixed (GLushort* code_ptr = code)
                    {
                        Delegates.glReplacementCodeusvSUN((GLushort*)code_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeusv(ref Int16 code)
            {
                unsafe
                {
                    fixed (Int16* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeusvSUN((GLushort*)code_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeusv(ref GLushort code)
            {
                unsafe
                {
                    fixed (GLushort* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeusvSUN((GLushort*)code_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeubv(GLubyte* code)
            {
                unsafe { Delegates.glReplacementCodeubvSUN((GLubyte*)code); }
            }
            
            public static 
            void ReplacementCodeubv(GLubyte[] code)
            {
                unsafe
                {
                    fixed (GLubyte* code_ptr = code)
                    {
                        Delegates.glReplacementCodeubvSUN((GLubyte*)code_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeubv(ref GLubyte code)
            {
                unsafe
                {
                    fixed (GLubyte* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeubvSUN((GLubyte*)code_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodePointer(GL.Enums.SUN_triangle_list type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glReplacementCodePointerSUN((GL.Enums.SUN_triangle_list)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void ReplacementCodePointer(GL.Enums.SUN_triangle_list type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glReplacementCodePointerSUN((GL.Enums.SUN_triangle_list)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void Color4ubVertex2f(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y)
            {
                Delegates.glColor4ubVertex2fSUN((GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex2fv(GLubyte* c, GLfloat* v)
            {
                unsafe { Delegates.glColor4ubVertex2fvSUN((GLubyte*)c, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex2fv(GLubyte* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4ubVertex2fvSUN((GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex2fv(GLubyte* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4ubVertex2fvSUN((GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex2fv(GLubyte[] c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color4ubVertex2fv(GLubyte[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4ubVertex2fv(GLubyte[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex2fv(ref GLubyte c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color4ubVertex2fv(ref GLubyte c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4ubVertex2fv(ref GLubyte c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4ubVertex2fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4ubVertex3f(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glColor4ubVertex3fSUN((GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex3fv(GLubyte* c, GLfloat* v)
            {
                unsafe { Delegates.glColor4ubVertex3fvSUN((GLubyte*)c, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex3fv(GLubyte* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4ubVertex3fvSUN((GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex3fv(GLubyte* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4ubVertex3fvSUN((GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex3fv(GLubyte[] c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color4ubVertex3fv(GLubyte[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4ubVertex3fv(GLubyte[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex3fv(ref GLubyte c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color4ubVertex3fv(ref GLubyte c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4ubVertex3fv(ref GLubyte c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4ubVertex3fvSUN((GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color3fVertex3f(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glColor3fVertex3fSUN((GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3fVertex3fv(GLfloat* c, GLfloat* v)
            {
                unsafe { Delegates.glColor3fVertex3fvSUN((GLfloat*)c, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3fVertex3fv(GLfloat* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor3fVertex3fvSUN((GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3fVertex3fv(GLfloat* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor3fVertex3fvSUN((GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3fVertex3fv(GLfloat[] c, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color3fVertex3fv(GLfloat[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color3fVertex3fv(GLfloat[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3fVertex3fv(ref GLfloat c, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color3fVertex3fv(ref GLfloat c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color3fVertex3fv(ref GLfloat c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Normal3fVertex3f(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glNormal3fVertex3fSUN((GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3fVertex3fv(GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glNormal3fVertex3fvSUN((GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3fVertex3fv(GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glNormal3fVertex3fvSUN((GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3fVertex3fv(GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glNormal3fVertex3fvSUN((GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3fVertex3fv(GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Normal3fVertex3fv(GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Normal3fVertex3fv(GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3fVertex3fv(ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Normal3fVertex3fv(ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Normal3fVertex3fv(ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glNormal3fVertex3fvSUN((GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4fNormal3fVertex3f(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glColor4fNormal3fVertex3fSUN((GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4fNormal3fVertex3fv(GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color4fNormal3fVertex3fv(GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4fNormal3fVertex3fv(GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4fNormal3fVertex3fv(ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3fv(ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void Color4fNormal3fVertex3fv(ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4fNormal3fVertex3fv(ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fVertex3f(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glTexCoord2fVertex3fSUN((GLfloat)s, (GLfloat)t, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fVertex3fv(GLfloat* tc, GLfloat* v)
            {
                unsafe { Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fVertex3fv(GLfloat* tc, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fVertex3fv(GLfloat* tc, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fVertex3fv(GLfloat[] tc, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fVertex3fv(GLfloat[] tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fVertex3fv(GLfloat[] tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fVertex3fv(ref GLfloat tc, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fVertex3fv(ref GLfloat tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fVertex3fv(ref GLfloat tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fVertex4f(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glTexCoord4fVertex4fSUN((GLfloat)s, (GLfloat)t, (GLfloat)p, (GLfloat)q, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fVertex4fv(GLfloat* tc, GLfloat* v)
            {
                unsafe { Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fVertex4fv(GLfloat* tc, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fVertex4fv(GLfloat* tc, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fVertex4fv(GLfloat[] tc, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fVertex4fv(GLfloat[] tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fVertex4fv(GLfloat[] tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fVertex4fv(ref GLfloat tc, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fVertex4fv(ref GLfloat tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fVertex4fv(ref GLfloat tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3f(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glTexCoord2fColor4ubVertex3fSUN((GLfloat)s, (GLfloat)t, (GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte* c, GLfloat* v)
            {
                unsafe { Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte[] c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte[] c, GLfloat[] v)
            {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, GLubyte[] c, ref GLfloat v)
            {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, ref GLubyte c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, ref GLubyte c, GLfloat[] v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat* tc, ref GLubyte c, ref GLfloat v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte* c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte* c, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte* c, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte[] c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, GLubyte[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, ref GLubyte c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, ref GLubyte c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3fv(GLfloat[] tc, ref GLubyte c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte* c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte* c, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte* c, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte[] c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, GLubyte[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, ref GLubyte c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, ref GLubyte c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4ubVertex3fv(ref GLfloat tc, ref GLubyte c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((GLfloat*)tc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor3fVertex3f(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glTexCoord2fColor3fVertex3fSUN((GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat* v)
            {
                unsafe { Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, GLfloat[] c, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat* tc, ref GLfloat c, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat* c, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor3fVertex3fv(GLfloat[] tc, GLfloat[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor3fVertex3fv(GLfloat[] tc, ref GLfloat c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat* c, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor3fVertex3fv(ref GLfloat tc, GLfloat[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor3fVertex3fv(ref GLfloat tc, ref GLfloat c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3f(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glTexCoord2fNormal3fVertex3fSUN((GLfloat)s, (GLfloat)t, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat* tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3f(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glTexCoord2fColor4fNormal3fVertex3fSUN((GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2fColor4fNormal3fVertex3fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4f(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glTexCoord4fColor4fNormal3fVertex4fSUN((GLfloat)s, (GLfloat)t, (GLfloat)p, (GLfloat)q, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4fColor4fNormal3fVertex4fv(ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiVertex3f(Int32 rc, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiVertex3fSUN((GLuint)rc, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiVertex3f(GLuint rc, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiVertex3fSUN((GLuint)rc, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(Int32* rc, GLfloat* v)
            {
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(GLuint* rc, GLfloat* v)
            {
                unsafe { Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(Int32* rc, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(GLuint* rc, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(Int32* rc, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(GLuint* rc, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(Int32[] rc, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(GLuint[] rc, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiVertex3fv(Int32[] rc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiVertex3fv(GLuint[] rc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiVertex3fv(Int32[] rc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiVertex3fv(GLuint[] rc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(ref Int32 rc, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3fv(ref GLuint rc, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiVertex3fv(ref Int32 rc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiVertex3fv(ref GLuint rc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiVertex3fv(ref Int32 rc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiVertex3fv(ref GLuint rc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3f(Int32 rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiColor4ubVertex3fSUN((GLuint)rc, (GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3f(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiColor4ubVertex3fSUN((GLuint)rc, (GLubyte)r, (GLubyte)g, (GLubyte)b, (GLubyte)a, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte* c, GLfloat* v)
            {
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte* c, GLfloat* v)
            {
                unsafe { Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte[] c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte[] c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte[] c, GLfloat[] v)
            {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte[] c, GLfloat[] v)
            {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, GLubyte[] c, ref GLfloat v)
            {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, GLubyte[] c, ref GLfloat v)
            {
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, ref GLubyte c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, ref GLubyte c, GLfloat* v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, ref GLubyte c, GLfloat[] v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, ref GLubyte c, GLfloat[] v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32* rc, ref GLubyte c, ref GLfloat v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint* rc, ref GLubyte c, ref GLfloat v)
            {
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte* c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte* c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte* c, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte* c, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte* c, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte* c, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte[] c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte[] c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, GLubyte[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, GLubyte[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, ref GLubyte c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, ref GLubyte c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, ref GLubyte c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, ref GLubyte c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(Int32[] rc, ref GLubyte c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(GLuint[] rc, ref GLubyte c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte* c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte* c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte* c, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte* c, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte* c, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte* c, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte[] c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte[] c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, GLubyte[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, GLubyte[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, ref GLubyte c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, ref GLubyte c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, ref GLubyte c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, ref GLubyte c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(ref Int32 rc, ref GLubyte c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3fv(ref GLuint rc, ref GLubyte c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLubyte* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((GLuint*)rc_ptr, (GLubyte*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3f(Int32 rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiColor3fVertex3fSUN((GLuint)rc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3f(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiColor3fVertex3fSUN((GLuint)rc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat* c, GLfloat* v)
            {
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat* v)
            {
                unsafe { Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat* c, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, GLfloat[] c, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, GLfloat[] c, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32* rc, ref GLfloat c, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint* rc, ref GLfloat c, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat* c, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat* c, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, GLfloat[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, GLfloat[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3fv(Int32[] rc, ref GLfloat c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3fv(GLuint[] rc, ref GLfloat c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat* c, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat* c, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, GLfloat[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, GLfloat[] c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor3fVertex3fv(ref Int32 rc, ref GLfloat c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3fv(ref GLuint rc, ref GLfloat c, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3f(Int32 rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiNormal3fVertex3fSUN((GLuint)rc, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3f(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiNormal3fVertex3fSUN((GLuint)rc, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat* n, GLfloat* v)
            {
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32* rc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint* rc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(Int32[] rc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(GLuint[] rc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(ref Int32 rc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3fv(ref GLuint rc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3f(Int32 rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3f(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3f(Int32 rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3f(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* v)
            {
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* v)
            {
                unsafe { Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3f(Int32 rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3f(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* n, GLfloat* v)
            {
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3f(Int32 rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3f(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((GLuint)rc, (GLfloat)s, (GLfloat)t, (GLfloat)r, (GLfloat)g, (GLfloat)b, (GLfloat)a, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                unsafe { Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint* rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(Int32[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat* tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, GLfloat[] n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat* c, ref GLfloat n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, GLfloat[] v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat* n, ref GLfloat v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat* v)
            {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref Int32 rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fv(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLuint* rc_ptr = &rc)
                    fixed (GLfloat* tc_ptr = &tc)
                    fixed (GLfloat* c_ptr = &c)
                    fixed (GLfloat* n_ptr = &n)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((GLuint*)rc_ptr, (GLfloat*)tc_ptr, (GLfloat*)c_ptr, (GLfloat*)n_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void DrawMeshArrays(GL.Enums.BeginMode mode, GLint first, GLsizei count, GLsizei width)
            {
                Delegates.glDrawMeshArraysSUN((GL.Enums.BeginMode)mode, (GLint)first, (GLsizei)count, (GLsizei)width);
            }
            
        }

        public static class INGR
        {
            public static 
            void BlendFuncSeparate(GL.Enums.GLenum sfactorRGB, GL.Enums.GLenum dfactorRGB, GL.Enums.GLenum sfactorAlpha, GL.Enums.GLenum dfactorAlpha)
            {
                Delegates.glBlendFuncSeparateINGR((GL.Enums.GLenum)sfactorRGB, (GL.Enums.GLenum)dfactorRGB, (GL.Enums.GLenum)sfactorAlpha, (GL.Enums.GLenum)dfactorAlpha);
            }
            
        }

        public static class NV
        {
            public static 
            void FlushVertexArrayRange()
            {
                Delegates.glFlushVertexArrayRangeNV();
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexArrayRange(GLsizei length, void* pointer)
            {
                unsafe { Delegates.glVertexArrayRangeNV((GLsizei)length, (void*)pointer); }
            }
            
            public static 
            void VertexArrayRange(GLsizei length, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexArrayRangeNV((GLsizei)length, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CombinerParameterfv(GL.Enums.NV_register_combiners pname, GLfloat* @params)
            {
                unsafe { Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (GLfloat*)@params); }
            }
            
            public static 
            void CombinerParameterfv(GL.Enums.NV_register_combiners pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CombinerParameterfv(GL.Enums.NV_register_combiners pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glCombinerParameterfvNV((GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CombinerParameterf(GL.Enums.NV_register_combiners pname, GLfloat param)
            {
                Delegates.glCombinerParameterfNV((GL.Enums.NV_register_combiners)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CombinerParameteriv(GL.Enums.NV_register_combiners pname, GLint* @params)
            {
                unsafe { Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (GLint*)@params); }
            }
            
            public static 
            void CombinerParameteriv(GL.Enums.NV_register_combiners pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CombinerParameteriv(GL.Enums.NV_register_combiners pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glCombinerParameterivNV((GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CombinerParameteri(GL.Enums.NV_register_combiners pname, GLint param)
            {
                Delegates.glCombinerParameteriNV((GL.Enums.NV_register_combiners)pname, (GLint)param);
            }
            
            public static 
            void CombinerInput(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners input, GL.Enums.NV_register_combiners mapping, GL.Enums.NV_register_combiners componentUsage)
            {
                Delegates.glCombinerInputNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)input, (GL.Enums.NV_register_combiners)mapping, (GL.Enums.NV_register_combiners)componentUsage);
            }
            
            public static 
            void CombinerOutput(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners abOutput, GL.Enums.NV_register_combiners cdOutput, GL.Enums.NV_register_combiners sumOutput, GL.Enums.NV_register_combiners scale, GL.Enums.NV_register_combiners bias, GL.Enums.Boolean abDotProduct, GL.Enums.Boolean cdDotProduct, GL.Enums.Boolean muxSum)
            {
                 Delegates.glCombinerOutputNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)abOutput, (GL.Enums.NV_register_combiners)cdOutput, (GL.Enums.NV_register_combiners)sumOutput, (GL.Enums.NV_register_combiners)scale, (GL.Enums.NV_register_combiners)bias, (GL.Enums.Boolean)abDotProduct, (GL.Enums.Boolean)cdDotProduct, (GL.Enums.Boolean)muxSum); 
            }
            
            public static 
            void FinalCombinerInput(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners input, GL.Enums.NV_register_combiners mapping, GL.Enums.NV_register_combiners componentUsage)
            {
                Delegates.glFinalCombinerInputNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)input, (GL.Enums.NV_register_combiners)mapping, (GL.Enums.NV_register_combiners)componentUsage);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerInputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetCombinerInputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetCombinerInputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerInputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLint* @params)
            {
                unsafe { Delegates.glGetCombinerInputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params); }
            }
            
            public static 
            void GetCombinerInputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerInputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetCombinerInputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerInputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerOutputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetCombinerOutputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetCombinerOutputParameterfv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerOutputParameterfvNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerOutputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, GLint* @params)
            {
                unsafe { Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLint*)@params); }
            }
            
            public static 
            void GetCombinerOutputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetCombinerOutputParameteriv(GL.Enums.NV_register_combiners stage, GL.Enums.NV_register_combiners portion, GL.Enums.NV_register_combiners pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerOutputParameterivNV((GL.Enums.NV_register_combiners)stage, (GL.Enums.NV_register_combiners)portion, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFinalCombinerInputParameterfv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetFinalCombinerInputParameterfv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetFinalCombinerInputParameterfv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetFinalCombinerInputParameterfvNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFinalCombinerInputParameteriv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLint* @params)
            {
                unsafe { Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params); }
            }
            
            public static 
            void GetFinalCombinerInputParameteriv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetFinalCombinerInputParameteriv(GL.Enums.NV_register_combiners variable, GL.Enums.NV_register_combiners pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetFinalCombinerInputParameterivNV((GL.Enums.NV_register_combiners)variable, (GL.Enums.NV_register_combiners)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFences(GLsizei n, Int32* fences)
            {
                    {
                        Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFences(GLsizei n, GLuint* fences)
            {
                unsafe { Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences); }
            }
            
            public static 
            void DeleteFences(GLsizei n, Int32[] fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = fences)
                    {
                        Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteFences(GLsizei n, GLuint[] fences)
            {
                unsafe
                {
                    fixed (GLuint* fences_ptr = fences)
                    {
                        Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            public static 
            void DeleteFences(GLsizei n, ref Int32 fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = &fences)
                    {
                        Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteFences(GLsizei n, ref GLuint fences)
            {
                unsafe
                {
                    fixed (GLuint* fences_ptr = &fences)
                    {
                        Delegates.glDeleteFencesNV((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFences(GLsizei n, Int32* fences)
            {
                fences = default(Int32*);
                    {
                        Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFences(GLsizei n, GLuint* fences)
            {
                unsafe { Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences); }
            }
            
            public static 
            void GenFences(GLsizei n, Int32[] fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = fences)
                    {
                        Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenFences(GLsizei n, GLuint[] fences)
            {
                unsafe
                {
                    fixed (GLuint* fences_ptr = fences)
                    {
                        Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            public static 
            void GenFences(GLsizei n, out Int32 fences)
            {
                fences = default(Int32);
                unsafe
                {
                    fixed (Int32* fences_ptr = &fences)
                    {
                        Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences_ptr);
                        fences = *fences_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenFences(GLsizei n, out GLuint fences)
            {
                fences = default(GLuint);
                unsafe
                {
                    fixed (GLuint* fences_ptr = &fences)
                    {
                        Delegates.glGenFencesNV((GLsizei)n, (GLuint*)fences_ptr);
                        fences = *fences_ptr;
                    }
                }
            }
            
            public static 
            GLboolean IsFence(Int32 fence)
            {
                return Delegates.glIsFenceNV((GLuint)fence);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsFence(GLuint fence)
            {
                return Delegates.glIsFenceNV((GLuint)fence);
            }
            
            public static 
            GLboolean TestFence(Int32 fence)
            {
                return Delegates.glTestFenceNV((GLuint)fence);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean TestFence(GLuint fence)
            {
                return Delegates.glTestFenceNV((GLuint)fence);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFenceiv(Int32 fence, GL.Enums.NV_fence pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFenceiv(GLuint fence, GL.Enums.NV_fence pname, GLint* @params)
            {
                unsafe { Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params); }
            }
            
            public static 
            void GetFenceiv(Int32 fence, GL.Enums.NV_fence pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetFenceiv(GLuint fence, GL.Enums.NV_fence pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetFenceiv(Int32 fence, GL.Enums.NV_fence pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetFenceiv(GLuint fence, GL.Enums.NV_fence pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetFenceivNV((GLuint)fence, (GL.Enums.NV_fence)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void FinishFence(Int32 fence)
            {
                Delegates.glFinishFenceNV((GLuint)fence);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FinishFence(GLuint fence)
            {
                Delegates.glFinishFenceNV((GLuint)fence);
            }
            
            public static 
            void SetFence(Int32 fence, GL.Enums.NV_fence condition)
            {
                Delegates.glSetFenceNV((GLuint)fence, (GL.Enums.NV_fence)condition);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SetFence(GLuint fence, GL.Enums.NV_fence condition)
            {
                Delegates.glSetFenceNV((GLuint)fence, (GL.Enums.NV_fence)condition);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MapControlPoints(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GL.Enums.Boolean packed, void* points)
            {
                    {
                        Delegates.glMapControlPointsNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)type, (GLsizei)ustride, (GLsizei)vstride, (GLint)uorder, (GLint)vorder, (GL.Enums.Boolean)packed, (void*)points);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MapControlPoints(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GL.Enums.Boolean packed, void* points)
            {
                unsafe { Delegates.glMapControlPointsNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)type, (GLsizei)ustride, (GLsizei)vstride, (GLint)uorder, (GLint)vorder, (GL.Enums.Boolean)packed, (void*)points); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLint* @params)
            {
                unsafe { Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params); }
            }
            
            public static 
            void MapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void MapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLfloat* @params)
            {
                unsafe { Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params); }
            }
            
            public static 
            void MapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void MapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapControlPoints(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GL.Enums.Boolean packed, void* points)
            {
                points = default(void*);
                    {
                        Delegates.glGetMapControlPointsNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)type, (GLsizei)ustride, (GLsizei)vstride, (GL.Enums.Boolean)packed, (void*)points);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapControlPoints(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GL.Enums.Boolean packed, void* points)
            {
                unsafe { Delegates.glGetMapControlPointsNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)type, (GLsizei)ustride, (GLsizei)vstride, (GL.Enums.Boolean)packed, (void*)points); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLint* @params)
            {
                unsafe { Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params); }
            }
            
            public static 
            void GetMapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetMapParameteriv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetMapParameterivNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetMapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetMapParameterfv(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetMapParameterfvNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, GLint* @params)
            {
                unsafe { Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params); }
            }
            
            public static 
            void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetMapAttribParameteriv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetMapAttribParameterivNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, Int32 index, GL.Enums.NV_evaluators pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetMapAttribParameterfv(GL.Enums.NV_evaluators target, GLuint index, GL.Enums.NV_evaluators pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetMapAttribParameterfvNV((GL.Enums.NV_evaluators)target, (GLuint)index, (GL.Enums.NV_evaluators)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void EvalMaps(GL.Enums.NV_evaluators target, GL.Enums.NV_evaluators mode)
            {
                Delegates.glEvalMapsNV((GL.Enums.NV_evaluators)target, (GL.Enums.NV_evaluators)mode);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void CombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, GLfloat* @params)
            {
                unsafe { Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params); }
            }
            
            public static 
            void CombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void CombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetCombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetCombinerStageParameterfv(GL.Enums.NV_register_combiners2 stage, GL.Enums.NV_register_combiners2 pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerStageParameterfvNV((GL.Enums.NV_register_combiners2)stage, (GL.Enums.NV_register_combiners2)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreProgramsResident(GLsizei n, Int32* programs, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    {
                        GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreProgramsResident(GLsizei n, GLuint* programs, GL.Enums.Boolean* residences)
            {
                unsafe { return Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs, (GL.Enums.Boolean*)residences); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreProgramsResident(GLsizei n, Int32[] programs, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    fixed (Int32* programs_ptr = programs)
                    {
                        GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs_ptr, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreProgramsResident(GLsizei n, GLuint[] programs, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    fixed (GLuint* programs_ptr = programs)
                    {
                        GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs_ptr, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreProgramsResident(GLsizei n, ref Int32 programs, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    fixed (Int32* programs_ptr = &programs)
                    {
                        GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs_ptr, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe GLboolean AreProgramsResident(GLsizei n, ref GLuint programs, GL.Enums.Boolean* residences)
            {
                residences = default(GL.Enums.Boolean*);
                    fixed (GLuint* programs_ptr = &programs)
                    {
                        GLboolean retval = Delegates.glAreProgramsResidentNV((GLsizei)n, (GLuint*)programs_ptr, (GL.Enums.Boolean*)residences);
                        return retval;
                    }
            }
            
            public static 
            void BindProgram(GL.Enums.NV_vertex_program target, Int32 id)
            {
                Delegates.glBindProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindProgram(GL.Enums.NV_vertex_program target, GLuint id)
            {
                Delegates.glBindProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeletePrograms(GLsizei n, Int32* programs)
            {
                    {
                        Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeletePrograms(GLsizei n, GLuint* programs)
            {
                unsafe { Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs); }
            }
            
            public static 
            void DeletePrograms(GLsizei n, Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeletePrograms(GLsizei n, GLuint[] programs)
            {
                unsafe
                {
                    fixed (GLuint* programs_ptr = programs)
                    {
                        Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            public static 
            void DeletePrograms(GLsizei n, ref Int32 programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeletePrograms(GLsizei n, ref GLuint programs)
            {
                unsafe
                {
                    fixed (GLuint* programs_ptr = &programs)
                    {
                        Delegates.glDeleteProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ExecuteProgram(GL.Enums.NV_vertex_program target, Int32 id, GLfloat* @params)
            {
                    {
                        Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ExecuteProgram(GL.Enums.NV_vertex_program target, GLuint id, GLfloat* @params)
            {
                unsafe { Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params); }
            }
            
            public static 
            void ExecuteProgram(GL.Enums.NV_vertex_program target, Int32 id, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ExecuteProgram(GL.Enums.NV_vertex_program target, GLuint id, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ExecuteProgram(GL.Enums.NV_vertex_program target, Int32 id, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ExecuteProgram(GL.Enums.NV_vertex_program target, GLuint id, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glExecuteProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenPrograms(GLsizei n, Int32* programs)
            {
                programs = default(Int32*);
                    {
                        Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenPrograms(GLsizei n, GLuint* programs)
            {
                unsafe { Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs); }
            }
            
            public static 
            void GenPrograms(GLsizei n, Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenPrograms(GLsizei n, GLuint[] programs)
            {
                unsafe
                {
                    fixed (GLuint* programs_ptr = programs)
                    {
                        Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            public static 
            void GenPrograms(GLsizei n, out Int32 programs)
            {
                programs = default(Int32);
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                        programs = *programs_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenPrograms(GLsizei n, out GLuint programs)
            {
                programs = default(GLuint);
                unsafe
                {
                    fixed (GLuint* programs_ptr = &programs)
                    {
                        Delegates.glGenProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                        programs = *programs_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramParameterdv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    {
                        Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramParameterdv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, GLdouble* @params)
            {
                unsafe { Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params); }
            }
            
            public static 
            void GetProgramParameterdv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramParameterdv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramParameterdv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramParameterdv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramParameterdvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramParameterfv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramParameterfv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetProgramParameterfv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramParameterfv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramParameterfv(GL.Enums.NV_vertex_program target, Int32 index, GL.Enums.NV_vertex_program pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramParameterfv(GL.Enums.NV_vertex_program target, GLuint index, GL.Enums.NV_vertex_program pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramParameterfvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramiv(Int32 id, GL.Enums.NV_vertex_program pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramiv(GLuint id, GL.Enums.NV_vertex_program pname, GLint* @params)
            {
                unsafe { Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params); }
            }
            
            public static 
            void GetProgramiv(Int32 id, GL.Enums.NV_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramiv(GLuint id, GL.Enums.NV_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramiv(Int32 id, GL.Enums.NV_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramiv(GLuint id, GL.Enums.NV_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramivNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramString(Int32 id, GL.Enums.NV_vertex_program pname, GLubyte* program)
            {
                program = default(GLubyte*);
                    {
                        Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramString(GLuint id, GL.Enums.NV_vertex_program pname, GLubyte* program)
            {
                unsafe { Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program); }
            }
            
            public static 
            void GetProgramString(Int32 id, GL.Enums.NV_vertex_program pname, GLubyte[] program)
            {
                unsafe
                {
                    fixed (GLubyte* program_ptr = program)
                    {
                        Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramString(GLuint id, GL.Enums.NV_vertex_program pname, GLubyte[] program)
            {
                unsafe
                {
                    fixed (GLubyte* program_ptr = program)
                    {
                        Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramString(Int32 id, GL.Enums.NV_vertex_program pname, out GLubyte program)
            {
                program = default(GLubyte);
                unsafe
                {
                    fixed (GLubyte* program_ptr = &program)
                    {
                        Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program_ptr);
                        program = *program_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramString(GLuint id, GL.Enums.NV_vertex_program pname, out GLubyte program)
            {
                program = default(GLubyte);
                unsafe
                {
                    fixed (GLubyte* program_ptr = &program)
                    {
                        Delegates.glGetProgramStringNV((GLuint)id, (GL.Enums.NV_vertex_program)pname, (GLubyte*)program_ptr);
                        program = *program_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, GLuint address, GL.Enums.NV_vertex_program pname, GLint* @params)
            {
                unsafe { Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params); }
            }
            
            public static 
            void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, GLuint address, GL.Enums.NV_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetTrackMatrixiv(GL.Enums.NV_vertex_program target, GLuint address, GL.Enums.NV_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetTrackMatrixivNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribdv(Int32 index, GL.Enums.NV_vertex_program pname, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    {
                        Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribdv(GLuint index, GL.Enums.NV_vertex_program pname, GLdouble* @params)
            {
                unsafe { Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params); }
            }
            
            public static 
            void GetVertexAttribdv(Int32 index, GL.Enums.NV_vertex_program pname, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribdv(GLuint index, GL.Enums.NV_vertex_program pname, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribdv(Int32 index, GL.Enums.NV_vertex_program pname, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribdv(GLuint index, GL.Enums.NV_vertex_program pname, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribdvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribfv(Int32 index, GL.Enums.NV_vertex_program pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribfv(GLuint index, GL.Enums.NV_vertex_program pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetVertexAttribfv(Int32 index, GL.Enums.NV_vertex_program pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribfv(GLuint index, GL.Enums.NV_vertex_program pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribfv(Int32 index, GL.Enums.NV_vertex_program pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribfv(GLuint index, GL.Enums.NV_vertex_program pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribfvNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribiv(Int32 index, GL.Enums.NV_vertex_program pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribiv(GLuint index, GL.Enums.NV_vertex_program pname, GLint* @params)
            {
                unsafe { Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params); }
            }
            
            public static 
            void GetVertexAttribiv(Int32 index, GL.Enums.NV_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribiv(GLuint index, GL.Enums.NV_vertex_program pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribiv(Int32 index, GL.Enums.NV_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribiv(GLuint index, GL.Enums.NV_vertex_program pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribivNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribPointerv(Int32 index, GL.Enums.NV_vertex_program pname, void* pointer)
            {
                pointer = default(void*);
                    {
                        Delegates.glGetVertexAttribPointervNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribPointerv(GLuint index, GL.Enums.NV_vertex_program pname, void* pointer)
            {
                unsafe { Delegates.glGetVertexAttribPointervNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer); }
            }
            
            public static 
            void GetVertexAttribPointerv(Int32 index, GL.Enums.NV_vertex_program pname, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetVertexAttribPointervNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribPointerv(GLuint index, GL.Enums.NV_vertex_program pname, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glGetVertexAttribPointervNV((GLuint)index, (GL.Enums.NV_vertex_program)pname, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            GLboolean IsProgram(Int32 id)
            {
                return Delegates.glIsProgramNV((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsProgram(GLuint id)
            {
                return Delegates.glIsProgramNV((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void LoadProgram(GL.Enums.NV_vertex_program target, Int32 id, GLsizei len, GLubyte* program)
            {
                    {
                        Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void LoadProgram(GL.Enums.NV_vertex_program target, GLuint id, GLsizei len, GLubyte* program)
            {
                unsafe { Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program); }
            }
            
            public static 
            void LoadProgram(GL.Enums.NV_vertex_program target, Int32 id, GLsizei len, GLubyte[] program)
            {
                unsafe
                {
                    fixed (GLubyte* program_ptr = program)
                    {
                        Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void LoadProgram(GL.Enums.NV_vertex_program target, GLuint id, GLsizei len, GLubyte[] program)
            {
                unsafe
                {
                    fixed (GLubyte* program_ptr = program)
                    {
                        Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program_ptr);
                    }
                }
            }
            
            public static 
            void LoadProgram(GL.Enums.NV_vertex_program target, Int32 id, GLsizei len, ref GLubyte program)
            {
                unsafe
                {
                    fixed (GLubyte* program_ptr = &program)
                    {
                        Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void LoadProgram(GL.Enums.NV_vertex_program target, GLuint id, GLsizei len, ref GLubyte program)
            {
                unsafe
                {
                    fixed (GLubyte* program_ptr = &program)
                    {
                        Delegates.glLoadProgramNV((GL.Enums.NV_vertex_program)target, (GLuint)id, (GLsizei)len, (GLubyte*)program_ptr);
                    }
                }
            }
            
            public static 
            void ProgramParameter4d(GL.Enums.NV_vertex_program target, Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glProgramParameter4dNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4d(GL.Enums.NV_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glProgramParameter4dNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameter4dv(GL.Enums.NV_vertex_program target, Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameter4dv(GL.Enums.NV_vertex_program target, GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void ProgramParameter4dv(GL.Enums.NV_vertex_program target, Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4dv(GL.Enums.NV_vertex_program target, GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramParameter4dv(GL.Enums.NV_vertex_program target, Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4dv(GL.Enums.NV_vertex_program target, GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramParameter4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramParameter4f(GL.Enums.NV_vertex_program target, Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glProgramParameter4fNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4f(GL.Enums.NV_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glProgramParameter4fNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameter4fv(GL.Enums.NV_vertex_program target, Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameter4fv(GL.Enums.NV_vertex_program target, GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void ProgramParameter4fv(GL.Enums.NV_vertex_program target, Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4fv(GL.Enums.NV_vertex_program target, GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramParameter4fv(GL.Enums.NV_vertex_program target, Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4fv(GL.Enums.NV_vertex_program target, GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramParameter4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameters4dv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, GLdouble* v)
            {
                    {
                        Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameters4dv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, GLdouble* v)
            {
                unsafe { Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v); }
            }
            
            public static 
            void ProgramParameters4dv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameters4dv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramParameters4dv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameters4dv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramParameters4dvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameters4fv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, GLfloat* v)
            {
                    {
                        Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameters4fv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, GLfloat* v)
            {
                unsafe { Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v); }
            }
            
            public static 
            void ProgramParameters4fv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameters4fv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramParameters4fv(GL.Enums.NV_vertex_program target, Int32 index, Int32 count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramParameters4fv(GL.Enums.NV_vertex_program target, GLuint index, GLuint count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramParameters4fvNV((GL.Enums.NV_vertex_program)target, (GLuint)index, (GLuint)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void RequestResidentPrograms(GLsizei n, Int32* programs)
            {
                    {
                        Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void RequestResidentPrograms(GLsizei n, GLuint* programs)
            {
                unsafe { Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs); }
            }
            
            public static 
            void RequestResidentPrograms(GLsizei n, Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void RequestResidentPrograms(GLsizei n, GLuint[] programs)
            {
                unsafe
                {
                    fixed (GLuint* programs_ptr = programs)
                    {
                        Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            public static 
            void RequestResidentPrograms(GLsizei n, ref Int32 programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void RequestResidentPrograms(GLsizei n, ref GLuint programs)
            {
                unsafe
                {
                    fixed (GLuint* programs_ptr = &programs)
                    {
                        Delegates.glRequestResidentProgramsNV((GLsizei)n, (GLuint*)programs_ptr);
                    }
                }
            }
            
            public static 
            void TrackMatrix(GL.Enums.NV_vertex_program target, Int32 address, GL.Enums.NV_vertex_program matrix, GL.Enums.NV_vertex_program transform)
            {
                Delegates.glTrackMatrixNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)matrix, (GL.Enums.NV_vertex_program)transform);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TrackMatrix(GL.Enums.NV_vertex_program target, GLuint address, GL.Enums.NV_vertex_program matrix, GL.Enums.NV_vertex_program transform)
            {
                Delegates.glTrackMatrixNV((GL.Enums.NV_vertex_program)target, (GLuint)address, (GL.Enums.NV_vertex_program)matrix, (GL.Enums.NV_vertex_program)transform);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribPointer(Int32 index, GLint fsize, GL.Enums.NV_vertex_program type, GLsizei stride, void* pointer)
            {
                    {
                        Delegates.glVertexAttribPointerNV((GLuint)index, (GLint)fsize, (GL.Enums.NV_vertex_program)type, (GLsizei)stride, (void*)pointer);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribPointer(GLuint index, GLint fsize, GL.Enums.NV_vertex_program type, GLsizei stride, void* pointer)
            {
                unsafe { Delegates.glVertexAttribPointerNV((GLuint)index, (GLint)fsize, (GL.Enums.NV_vertex_program)type, (GLsizei)stride, (void*)pointer); }
            }
            
            public static 
            void VertexAttribPointer(Int32 index, GLint fsize, GL.Enums.NV_vertex_program type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexAttribPointerNV((GLuint)index, (GLint)fsize, (GL.Enums.NV_vertex_program)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribPointer(GLuint index, GLint fsize, GL.Enums.NV_vertex_program type, GLsizei stride, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexAttribPointerNV((GLuint)index, (GLint)fsize, (GL.Enums.NV_vertex_program)type, (GLsizei)stride, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void VertexAttrib1d(Int32 index, GLdouble x)
            {
                Delegates.glVertexAttrib1dNV((GLuint)index, (GLdouble)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1d(GLuint index, GLdouble x)
            {
                Delegates.glVertexAttrib1dNV((GLuint)index, (GLdouble)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1dv(Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1dv(GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttrib1dv(Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1dv(GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1dv(Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1dv(GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1f(Int32 index, GLfloat x)
            {
                Delegates.glVertexAttrib1fNV((GLuint)index, (GLfloat)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1f(GLuint index, GLfloat x)
            {
                Delegates.glVertexAttrib1fNV((GLuint)index, (GLfloat)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1fv(Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1fv(GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttrib1fv(Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1fv(GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1fv(Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1fv(GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1s(Int32 index, GLshort x)
            {
                Delegates.glVertexAttrib1sNV((GLuint)index, (GLshort)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1s(GLuint index, GLshort x)
            {
                Delegates.glVertexAttrib1sNV((GLuint)index, (GLshort)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib1sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2d(Int32 index, GLdouble x, GLdouble y)
            {
                Delegates.glVertexAttrib2dNV((GLuint)index, (GLdouble)x, (GLdouble)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
            {
                Delegates.glVertexAttrib2dNV((GLuint)index, (GLdouble)x, (GLdouble)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2dv(Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2dv(GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttrib2dv(Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2dv(GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2dv(Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2dv(GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2f(Int32 index, GLfloat x, GLfloat y)
            {
                Delegates.glVertexAttrib2fNV((GLuint)index, (GLfloat)x, (GLfloat)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
            {
                Delegates.glVertexAttrib2fNV((GLuint)index, (GLfloat)x, (GLfloat)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2fv(Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2fv(GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttrib2fv(Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2fv(GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2fv(Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2fv(GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2s(Int32 index, GLshort x, GLshort y)
            {
                Delegates.glVertexAttrib2sNV((GLuint)index, (GLshort)x, (GLshort)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2s(GLuint index, GLshort x, GLshort y)
            {
                Delegates.glVertexAttrib2sNV((GLuint)index, (GLshort)x, (GLshort)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib2sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3d(Int32 index, GLdouble x, GLdouble y, GLdouble z)
            {
                Delegates.glVertexAttrib3dNV((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
            {
                Delegates.glVertexAttrib3dNV((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3dv(Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3dv(GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttrib3dv(Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3dv(GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3dv(Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3dv(GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3f(Int32 index, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glVertexAttrib3fNV((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glVertexAttrib3fNV((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3fv(Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3fv(GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttrib3fv(Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3fv(GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3fv(Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3fv(GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3s(Int32 index, GLshort x, GLshort y, GLshort z)
            {
                Delegates.glVertexAttrib3sNV((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
            {
                Delegates.glVertexAttrib3sNV((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib3sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4d(Int32 index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glVertexAttrib4dNV((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glVertexAttrib4dNV((GLuint)index, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4dv(Int32 index, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4dv(GLuint index, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttrib4dv(Int32 index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4dv(GLuint index, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4dv(Int32 index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4dv(GLuint index, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4dvNV((GLuint)index, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4f(Int32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glVertexAttrib4fNV((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glVertexAttrib4fNV((GLuint)index, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4fv(Int32 index, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4fv(GLuint index, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttrib4fv(Int32 index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4fv(GLuint index, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4fv(Int32 index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4fv(GLuint index, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4fvNV((GLuint)index, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4s(Int32 index, GLshort x, GLshort y, GLshort z, GLshort w)
            {
                Delegates.glVertexAttrib4sNV((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
            {
                Delegates.glVertexAttrib4sNV((GLuint)index, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4sv(Int32 index, GLshort* v)
            {
                    {
                        Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4sv(GLuint index, GLshort* v)
            {
                unsafe { Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v); }
            }
            
            public static 
            void VertexAttrib4sv(Int32 index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4sv(GLuint index, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4sv(Int32 index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4sv(GLuint index, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4svNV((GLuint)index, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4ub(Int32 index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
            {
                Delegates.glVertexAttrib4ubNV((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4ub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
            {
                Delegates.glVertexAttrib4ubNV((GLuint)index, (GLubyte)x, (GLubyte)y, (GLubyte)z, (GLubyte)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4ubv(Int32 index, GLubyte* v)
            {
                    {
                        Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4ubv(GLuint index, GLubyte* v)
            {
                unsafe { Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v); }
            }
            
            public static 
            void VertexAttrib4ubv(Int32 index, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4ubv(GLuint index, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4ubv(Int32 index, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4ubv(GLuint index, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ubvNV((GLuint)index, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1dv(Int32 index, GLsizei count, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1dv(GLuint index, GLsizei count, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttribs1dv(Int32 index, GLsizei count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1dv(GLuint index, GLsizei count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs1dv(Int32 index, GLsizei count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1dv(GLuint index, GLsizei count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1fv(Int32 index, GLsizei count, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1fv(GLuint index, GLsizei count, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttribs1fv(Int32 index, GLsizei count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1fv(GLuint index, GLsizei count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs1fv(Int32 index, GLsizei count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1fv(GLuint index, GLsizei count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1sv(Int32 index, GLsizei count, GLshort* v)
            {
                    {
                        Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1sv(GLuint index, GLsizei count, GLshort* v)
            {
                unsafe { Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v); }
            }
            
            public static 
            void VertexAttribs1sv(Int32 index, GLsizei count, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1sv(GLuint index, GLsizei count, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs1sv(Int32 index, GLsizei count, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1sv(GLuint index, GLsizei count, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2dv(Int32 index, GLsizei count, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2dv(GLuint index, GLsizei count, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttribs2dv(Int32 index, GLsizei count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2dv(GLuint index, GLsizei count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs2dv(Int32 index, GLsizei count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2dv(GLuint index, GLsizei count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2fv(Int32 index, GLsizei count, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2fv(GLuint index, GLsizei count, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttribs2fv(Int32 index, GLsizei count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2fv(GLuint index, GLsizei count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs2fv(Int32 index, GLsizei count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2fv(GLuint index, GLsizei count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2sv(Int32 index, GLsizei count, GLshort* v)
            {
                    {
                        Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2sv(GLuint index, GLsizei count, GLshort* v)
            {
                unsafe { Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v); }
            }
            
            public static 
            void VertexAttribs2sv(Int32 index, GLsizei count, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2sv(GLuint index, GLsizei count, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs2sv(Int32 index, GLsizei count, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2sv(GLuint index, GLsizei count, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3dv(Int32 index, GLsizei count, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3dv(GLuint index, GLsizei count, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttribs3dv(Int32 index, GLsizei count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3dv(GLuint index, GLsizei count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs3dv(Int32 index, GLsizei count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3dv(GLuint index, GLsizei count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3fv(Int32 index, GLsizei count, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3fv(GLuint index, GLsizei count, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttribs3fv(Int32 index, GLsizei count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3fv(GLuint index, GLsizei count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs3fv(Int32 index, GLsizei count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3fv(GLuint index, GLsizei count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3sv(Int32 index, GLsizei count, GLshort* v)
            {
                    {
                        Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3sv(GLuint index, GLsizei count, GLshort* v)
            {
                unsafe { Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v); }
            }
            
            public static 
            void VertexAttribs3sv(Int32 index, GLsizei count, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3sv(GLuint index, GLsizei count, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs3sv(Int32 index, GLsizei count, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3sv(GLuint index, GLsizei count, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4dv(Int32 index, GLsizei count, GLdouble* v)
            {
                    {
                        Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4dv(GLuint index, GLsizei count, GLdouble* v)
            {
                unsafe { Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v); }
            }
            
            public static 
            void VertexAttribs4dv(Int32 index, GLsizei count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4dv(GLuint index, GLsizei count, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs4dv(Int32 index, GLsizei count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4dv(GLuint index, GLsizei count, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4dvNV((GLuint)index, (GLsizei)count, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4fv(Int32 index, GLsizei count, GLfloat* v)
            {
                    {
                        Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4fv(GLuint index, GLsizei count, GLfloat* v)
            {
                unsafe { Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v); }
            }
            
            public static 
            void VertexAttribs4fv(Int32 index, GLsizei count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4fv(GLuint index, GLsizei count, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs4fv(Int32 index, GLsizei count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4fv(GLuint index, GLsizei count, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4fvNV((GLuint)index, (GLsizei)count, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4sv(Int32 index, GLsizei count, GLshort* v)
            {
                    {
                        Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4sv(GLuint index, GLsizei count, GLshort* v)
            {
                unsafe { Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v); }
            }
            
            public static 
            void VertexAttribs4sv(Int32 index, GLsizei count, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4sv(GLuint index, GLsizei count, GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs4sv(Int32 index, GLsizei count, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4sv(GLuint index, GLsizei count, ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4svNV((GLuint)index, (GLsizei)count, (GLshort*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4ubv(Int32 index, GLsizei count, GLubyte* v)
            {
                    {
                        Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4ubv(GLuint index, GLsizei count, GLubyte* v)
            {
                unsafe { Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v); }
            }
            
            public static 
            void VertexAttribs4ubv(Int32 index, GLsizei count, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4ubv(GLuint index, GLsizei count, GLubyte[] v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs4ubv(Int32 index, GLsizei count, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4ubv(GLuint index, GLsizei count, ref GLubyte v)
            {
                unsafe
                {
                    fixed (GLubyte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4ubvNV((GLuint)index, (GLsizei)count, (GLubyte*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenOcclusionQueries(GLsizei n, Int32* ids)
            {
                ids = default(Int32*);
                    {
                        Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenOcclusionQueries(GLsizei n, GLuint* ids)
            {
                unsafe { Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids); }
            }
            
            public static 
            void GenOcclusionQueries(GLsizei n, Int32[] ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = ids)
                    {
                        Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenOcclusionQueries(GLsizei n, GLuint[] ids)
            {
                unsafe
                {
                    fixed (GLuint* ids_ptr = ids)
                    {
                        Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            public static 
            void GenOcclusionQueries(GLsizei n, out Int32 ids)
            {
                ids = default(Int32);
                unsafe
                {
                    fixed (Int32* ids_ptr = &ids)
                    {
                        Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
                        ids = *ids_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenOcclusionQueries(GLsizei n, out GLuint ids)
            {
                ids = default(GLuint);
                unsafe
                {
                    fixed (GLuint* ids_ptr = &ids)
                    {
                        Delegates.glGenOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
                        ids = *ids_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteOcclusionQueries(GLsizei n, Int32* ids)
            {
                    {
                        Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteOcclusionQueries(GLsizei n, GLuint* ids)
            {
                unsafe { Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids); }
            }
            
            public static 
            void DeleteOcclusionQueries(GLsizei n, Int32[] ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = ids)
                    {
                        Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteOcclusionQueries(GLsizei n, GLuint[] ids)
            {
                unsafe
                {
                    fixed (GLuint* ids_ptr = ids)
                    {
                        Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            public static 
            void DeleteOcclusionQueries(GLsizei n, ref Int32 ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = &ids)
                    {
                        Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteOcclusionQueries(GLsizei n, ref GLuint ids)
            {
                unsafe
                {
                    fixed (GLuint* ids_ptr = &ids)
                    {
                        Delegates.glDeleteOcclusionQueriesNV((GLsizei)n, (GLuint*)ids_ptr);
                    }
                }
            }
            
            public static 
            GLboolean IsOcclusionQuery(Int32 id)
            {
                return Delegates.glIsOcclusionQueryNV((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsOcclusionQuery(GLuint id)
            {
                return Delegates.glIsOcclusionQueryNV((GLuint)id);
            }
            
            public static 
            void BeginOcclusionQuery(Int32 id)
            {
                Delegates.glBeginOcclusionQueryNV((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BeginOcclusionQuery(GLuint id)
            {
                Delegates.glBeginOcclusionQueryNV((GLuint)id);
            }
            
            public static 
            void EndOcclusionQuery()
            {
                Delegates.glEndOcclusionQueryNV();
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetOcclusionQueryiv(Int32 id, GL.Enums.NV_occlusion_query pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetOcclusionQueryiv(GLuint id, GL.Enums.NV_occlusion_query pname, GLint* @params)
            {
                unsafe { Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params); }
            }
            
            public static 
            void GetOcclusionQueryiv(Int32 id, GL.Enums.NV_occlusion_query pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetOcclusionQueryiv(GLuint id, GL.Enums.NV_occlusion_query pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetOcclusionQueryiv(Int32 id, GL.Enums.NV_occlusion_query pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetOcclusionQueryiv(GLuint id, GL.Enums.NV_occlusion_query pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetOcclusionQueryivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetOcclusionQueryuiv(Int32 id, GL.Enums.NV_occlusion_query pname, Int32* @params)
            {
                @params = default(Int32*);
                    {
                        Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetOcclusionQueryuiv(GLuint id, GL.Enums.NV_occlusion_query pname, GLuint* @params)
            {
                unsafe { Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params); }
            }
            
            public static 
            void GetOcclusionQueryuiv(Int32 id, GL.Enums.NV_occlusion_query pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetOcclusionQueryuiv(GLuint id, GL.Enums.NV_occlusion_query pname, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetOcclusionQueryuiv(Int32 id, GL.Enums.NV_occlusion_query pname, out Int32 @params)
            {
                @params = default(Int32);
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetOcclusionQueryuiv(GLuint id, GL.Enums.NV_occlusion_query pname, out GLuint @params)
            {
                @params = default(GLuint);
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glGetOcclusionQueryuivNV((GLuint)id, (GL.Enums.NV_occlusion_query)pname, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void PointParameteri(GL.Enums.NV_point_sprite pname, GLint param)
            {
                Delegates.glPointParameteriNV((GL.Enums.NV_point_sprite)pname, (GLint)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PointParameteriv(GL.Enums.NV_point_sprite pname, GLint* @params)
            {
                unsafe { Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (GLint*)@params); }
            }
            
            public static 
            void PointParameteriv(GL.Enums.NV_point_sprite pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void PointParameteriv(GL.Enums.NV_point_sprite pname, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glPointParameterivNV((GL.Enums.NV_point_sprite)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4f(Int32 id, GLsizei len, GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                    {
                        Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4f(GLuint id, GLsizei len, GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                unsafe { Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w); }
            }
            
            public static 
            void ProgramNamedParameter4f(Int32 id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4f(GLuint id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
                    }
                }
            }
            
            public static 
            void ProgramNamedParameter4f(Int32 id, GLsizei len, ref GLubyte name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4f(GLuint id, GLsizei len, ref GLubyte name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4fNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4d(Int32 id, GLsizei len, GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                    {
                        Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4d(GLuint id, GLsizei len, GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                unsafe { Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w); }
            }
            
            public static 
            void ProgramNamedParameter4d(Int32 id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4d(GLuint id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
                    }
                }
            }
            
            public static 
            void ProgramNamedParameter4d(Int32 id, GLsizei len, ref GLubyte name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4d(GLuint id, GLsizei len, ref GLubyte name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4dNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte* name, GLfloat* v)
            {
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte* name, GLfloat* v)
            {
                unsafe { Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte* name, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte* name, GLfloat[] v)
            {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte* name, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte* name, ref GLfloat v)
            {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte[] name, GLfloat* v)
            {
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte[] name, GLfloat* v)
            {
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte[] name, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramNamedParameter4fv(Int32 id, GLsizei len, GLubyte[] name, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4fv(GLuint id, GLsizei len, GLubyte[] name, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(Int32 id, GLsizei len, ref GLubyte name, GLfloat* v)
            {
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4fv(GLuint id, GLsizei len, ref GLubyte name, GLfloat* v)
            {
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v);
                    }
            }
            
            public static 
            void ProgramNamedParameter4fv(Int32 id, GLsizei len, ref GLubyte name, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4fv(GLuint id, GLsizei len, ref GLubyte name, GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramNamedParameter4fv(Int32 id, GLsizei len, ref GLubyte name, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4fv(GLuint id, GLsizei len, ref GLubyte name, ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte* name, GLdouble* v)
            {
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte* name, GLdouble* v)
            {
                unsafe { Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte* name, GLdouble[] v)
            {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte* name, GLdouble[] v)
            {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte* name, ref GLdouble v)
            {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte* name, ref GLdouble v)
            {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)v_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte[] name, GLdouble* v)
            {
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte[] name, GLdouble* v)
            {
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v);
                    }
            }
            
            public static 
            void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte[] name, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramNamedParameter4dv(Int32 id, GLsizei len, GLubyte[] name, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4dv(GLuint id, GLsizei len, GLubyte[] name, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(Int32 id, GLsizei len, ref GLubyte name, GLdouble* v)
            {
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4dv(GLuint id, GLsizei len, ref GLubyte name, GLdouble* v)
            {
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v);
                    }
            }
            
            public static 
            void ProgramNamedParameter4dv(Int32 id, GLsizei len, ref GLubyte name, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4dv(GLuint id, GLsizei len, ref GLubyte name, GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void ProgramNamedParameter4dv(Int32 id, GLsizei len, ref GLubyte name, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4dv(GLuint id, GLsizei len, ref GLubyte name, ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte* name, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte* name, GLfloat* @params)
            {
                unsafe { Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte* name, GLfloat[] @params)
            {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte* name, GLfloat[] @params)
            {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte* name, out GLfloat @params)
            {
                @params = default(GLfloat);
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte* name, out GLfloat @params)
            {
                @params = default(GLfloat);
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte[] name, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte[] name, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params);
                    }
            }
            
            public static 
            void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte[] name, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramNamedParameterfv(Int32 id, GLsizei len, GLubyte[] name, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameterfv(GLuint id, GLsizei len, GLubyte[] name, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(Int32 id, GLsizei len, ref GLubyte name, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterfv(GLuint id, GLsizei len, ref GLubyte name, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params);
                    }
            }
            
            public static 
            void GetProgramNamedParameterfv(Int32 id, GLsizei len, ref GLubyte name, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameterfv(GLuint id, GLsizei len, ref GLubyte name, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramNamedParameterfv(Int32 id, GLsizei len, ref GLubyte name, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameterfv(GLuint id, GLsizei len, ref GLubyte name, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte* name, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte* name, GLdouble* @params)
            {
                unsafe { Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte* name, GLdouble[] @params)
            {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte* name, GLdouble[] @params)
            {
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params_ptr);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte* name, out GLdouble @params)
            {
                @params = default(GLdouble);
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte* name, out GLdouble @params)
            {
                @params = default(GLdouble);
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte[] name, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte[] name, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    fixed (GLubyte* name_ptr = name)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params);
                    }
            }
            
            public static 
            void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte[] name, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramNamedParameterdv(Int32 id, GLsizei len, GLubyte[] name, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameterdv(GLuint id, GLsizei len, GLubyte[] name, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLubyte* name_ptr = name)
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(Int32 id, GLsizei len, ref GLubyte name, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameterdv(GLuint id, GLsizei len, ref GLubyte name, GLdouble* @params)
            {
                @params = default(GLdouble*);
                    fixed (GLubyte* name_ptr = &name)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params);
                    }
            }
            
            public static 
            void GetProgramNamedParameterdv(Int32 id, GLsizei len, ref GLubyte name, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameterdv(GLuint id, GLsizei len, ref GLubyte name, GLdouble[] @params)
            {
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLdouble* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramNamedParameterdv(Int32 id, GLsizei len, ref GLubyte name, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameterdv(GLuint id, GLsizei len, ref GLubyte name, out GLdouble @params)
            {
                @params = default(GLdouble);
                unsafe
                {
                    fixed (GLubyte* name_ptr = &name)
                    fixed (GLdouble* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((GLuint)id, (GLsizei)len, (GLubyte*)name_ptr, (GLdouble*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void Vertex2h(Int16 x, Int16 y)
            {
                Delegates.glVertex2hNV((GLhalfNV)x, (GLhalfNV)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex2h(GLhalfNV x, GLhalfNV y)
            {
                Delegates.glVertex2hNV((GLhalfNV)x, (GLhalfNV)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex2hv(Int16* v)
            {
                    {
                        Delegates.glVertex2hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex2hv(GLhalfNV* v)
            {
                unsafe { Delegates.glVertex2hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void Vertex2hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertex2hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex2hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertex2hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Vertex2hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertex2hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex2hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertex2hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Vertex3h(Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertex3hNV((GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex3h(GLhalfNV x, GLhalfNV y, GLhalfNV z)
            {
                Delegates.glVertex3hNV((GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex3hv(Int16* v)
            {
                    {
                        Delegates.glVertex3hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex3hv(GLhalfNV* v)
            {
                unsafe { Delegates.glVertex3hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void Vertex3hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertex3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex3hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertex3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Vertex3hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertex3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex3hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertex3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Vertex4h(Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertex4hNV((GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z, (GLhalfNV)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex4h(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
            {
                Delegates.glVertex4hNV((GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z, (GLhalfNV)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex4hv(Int16* v)
            {
                    {
                        Delegates.glVertex4hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex4hv(GLhalfNV* v)
            {
                unsafe { Delegates.glVertex4hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void Vertex4hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertex4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex4hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertex4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Vertex4hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertex4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Vertex4hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertex4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Normal3h(Int16 nx, Int16 ny, Int16 nz)
            {
                Delegates.glNormal3hNV((GLhalfNV)nx, (GLhalfNV)ny, (GLhalfNV)nz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Normal3h(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz)
            {
                Delegates.glNormal3hNV((GLhalfNV)nx, (GLhalfNV)ny, (GLhalfNV)nz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3hv(Int16* v)
            {
                    {
                        Delegates.glNormal3hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3hv(GLhalfNV* v)
            {
                unsafe { Delegates.glNormal3hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void Normal3hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glNormal3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Normal3hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glNormal3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Normal3hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glNormal3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Normal3hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glNormal3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color3h(Int16 red, Int16 green, Int16 blue)
            {
                Delegates.glColor3hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Color3h(GLhalfNV red, GLhalfNV green, GLhalfNV blue)
            {
                Delegates.glColor3hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3hv(Int16* v)
            {
                    {
                        Delegates.glColor3hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3hv(GLhalfNV* v)
            {
                unsafe { Delegates.glColor3hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void Color3hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glColor3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Color3hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glColor3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color3hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glColor3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Color3hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glColor3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4h(Int16 red, Int16 green, Int16 blue, Int16 alpha)
            {
                Delegates.glColor4hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue, (GLhalfNV)alpha);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Color4h(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha)
            {
                Delegates.glColor4hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue, (GLhalfNV)alpha);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4hv(Int16* v)
            {
                    {
                        Delegates.glColor4hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4hv(GLhalfNV* v)
            {
                unsafe { Delegates.glColor4hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void Color4hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glColor4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Color4hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glColor4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void Color4hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glColor4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void Color4hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glColor4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord1h(Int16 s)
            {
                Delegates.glTexCoord1hNV((GLhalfNV)s);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord1h(GLhalfNV s)
            {
                Delegates.glTexCoord1hNV((GLhalfNV)s);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord1hv(Int16* v)
            {
                    {
                        Delegates.glTexCoord1hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord1hv(GLhalfNV* v)
            {
                unsafe { Delegates.glTexCoord1hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void TexCoord1hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTexCoord1hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord1hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glTexCoord1hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord1hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTexCoord1hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord1hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glTexCoord1hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2h(Int16 s, Int16 t)
            {
                Delegates.glTexCoord2hNV((GLhalfNV)s, (GLhalfNV)t);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord2h(GLhalfNV s, GLhalfNV t)
            {
                Delegates.glTexCoord2hNV((GLhalfNV)s, (GLhalfNV)t);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2hv(Int16* v)
            {
                    {
                        Delegates.glTexCoord2hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2hv(GLhalfNV* v)
            {
                unsafe { Delegates.glTexCoord2hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void TexCoord2hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTexCoord2hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord2hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glTexCoord2hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord2hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTexCoord2hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord2hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glTexCoord2hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord3h(Int16 s, Int16 t, Int16 r)
            {
                Delegates.glTexCoord3hNV((GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord3h(GLhalfNV s, GLhalfNV t, GLhalfNV r)
            {
                Delegates.glTexCoord3hNV((GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord3hv(Int16* v)
            {
                    {
                        Delegates.glTexCoord3hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord3hv(GLhalfNV* v)
            {
                unsafe { Delegates.glTexCoord3hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void TexCoord3hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTexCoord3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord3hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glTexCoord3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord3hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTexCoord3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord3hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glTexCoord3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4h(Int16 s, Int16 t, Int16 r, Int16 q)
            {
                Delegates.glTexCoord4hNV((GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r, (GLhalfNV)q);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord4h(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)
            {
                Delegates.glTexCoord4hNV((GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r, (GLhalfNV)q);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4hv(Int16* v)
            {
                    {
                        Delegates.glTexCoord4hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4hv(GLhalfNV* v)
            {
                unsafe { Delegates.glTexCoord4hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void TexCoord4hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTexCoord4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord4hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glTexCoord4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void TexCoord4hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTexCoord4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TexCoord4hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glTexCoord4hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1h(GL.Enums.NV_half_float target, Int16 s)
            {
                Delegates.glMultiTexCoord1hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord1h(GL.Enums.NV_half_float target, GLhalfNV s)
            {
                Delegates.glMultiTexCoord1hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1hv(GL.Enums.NV_half_float target, Int16* v)
            {
                    {
                        Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1hv(GL.Enums.NV_half_float target, GLhalfNV* v)
            {
                unsafe { Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v); }
            }
            
            public static 
            void MultiTexCoord1hv(GL.Enums.NV_half_float target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord1hv(GL.Enums.NV_half_float target, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord1hv(GL.Enums.NV_half_float target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord1hv(GL.Enums.NV_half_float target, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2h(GL.Enums.NV_half_float target, Int16 s, Int16 t)
            {
                Delegates.glMultiTexCoord2hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord2h(GL.Enums.NV_half_float target, GLhalfNV s, GLhalfNV t)
            {
                Delegates.glMultiTexCoord2hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2hv(GL.Enums.NV_half_float target, Int16* v)
            {
                    {
                        Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2hv(GL.Enums.NV_half_float target, GLhalfNV* v)
            {
                unsafe { Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v); }
            }
            
            public static 
            void MultiTexCoord2hv(GL.Enums.NV_half_float target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord2hv(GL.Enums.NV_half_float target, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord2hv(GL.Enums.NV_half_float target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord2hv(GL.Enums.NV_half_float target, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3h(GL.Enums.NV_half_float target, Int16 s, Int16 t, Int16 r)
            {
                Delegates.glMultiTexCoord3hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord3h(GL.Enums.NV_half_float target, GLhalfNV s, GLhalfNV t, GLhalfNV r)
            {
                Delegates.glMultiTexCoord3hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3hv(GL.Enums.NV_half_float target, Int16* v)
            {
                    {
                        Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3hv(GL.Enums.NV_half_float target, GLhalfNV* v)
            {
                unsafe { Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v); }
            }
            
            public static 
            void MultiTexCoord3hv(GL.Enums.NV_half_float target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord3hv(GL.Enums.NV_half_float target, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord3hv(GL.Enums.NV_half_float target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord3hv(GL.Enums.NV_half_float target, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4h(GL.Enums.NV_half_float target, Int16 s, Int16 t, Int16 r, Int16 q)
            {
                Delegates.glMultiTexCoord4hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r, (GLhalfNV)q);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord4h(GL.Enums.NV_half_float target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)
            {
                Delegates.glMultiTexCoord4hNV((GL.Enums.NV_half_float)target, (GLhalfNV)s, (GLhalfNV)t, (GLhalfNV)r, (GLhalfNV)q);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4hv(GL.Enums.NV_half_float target, Int16* v)
            {
                    {
                        Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4hv(GL.Enums.NV_half_float target, GLhalfNV* v)
            {
                unsafe { Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v); }
            }
            
            public static 
            void MultiTexCoord4hv(GL.Enums.NV_half_float target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord4hv(GL.Enums.NV_half_float target, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void MultiTexCoord4hv(GL.Enums.NV_half_float target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord4hv(GL.Enums.NV_half_float target, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4hvNV((GL.Enums.NV_half_float)target, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void FogCoordh(Int16 fog)
            {
                Delegates.glFogCoordhNV((GLhalfNV)fog);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FogCoordh(GLhalfNV fog)
            {
                Delegates.glFogCoordhNV((GLhalfNV)fog);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordhv(Int16* fog)
            {
                    {
                        Delegates.glFogCoordhvNV((GLhalfNV*)fog);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordhv(GLhalfNV* fog)
            {
                unsafe { Delegates.glFogCoordhvNV((GLhalfNV*)fog); }
            }
            
            public static 
            void FogCoordhv(Int16[] fog)
            {
                unsafe
                {
                    fixed (Int16* fog_ptr = fog)
                    {
                        Delegates.glFogCoordhvNV((GLhalfNV*)fog_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FogCoordhv(GLhalfNV[] fog)
            {
                unsafe
                {
                    fixed (GLhalfNV* fog_ptr = fog)
                    {
                        Delegates.glFogCoordhvNV((GLhalfNV*)fog_ptr);
                    }
                }
            }
            
            public static 
            void FogCoordhv(ref Int16 fog)
            {
                unsafe
                {
                    fixed (Int16* fog_ptr = &fog)
                    {
                        Delegates.glFogCoordhvNV((GLhalfNV*)fog_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FogCoordhv(ref GLhalfNV fog)
            {
                unsafe
                {
                    fixed (GLhalfNV* fog_ptr = &fog)
                    {
                        Delegates.glFogCoordhvNV((GLhalfNV*)fog_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3h(Int16 red, Int16 green, Int16 blue)
            {
                Delegates.glSecondaryColor3hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3h(GLhalfNV red, GLhalfNV green, GLhalfNV blue)
            {
                Delegates.glSecondaryColor3hNV((GLhalfNV)red, (GLhalfNV)green, (GLhalfNV)blue);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3hv(Int16* v)
            {
                    {
                        Delegates.glSecondaryColor3hvNV((GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3hv(GLhalfNV* v)
            {
                unsafe { Delegates.glSecondaryColor3hvNV((GLhalfNV*)v); }
            }
            
            public static 
            void SecondaryColor3hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3hv(GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void SecondaryColor3hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3hv(ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3hvNV((GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexWeighth(Int16 weight)
            {
                Delegates.glVertexWeighthNV((GLhalfNV)weight);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexWeighth(GLhalfNV weight)
            {
                Delegates.glVertexWeighthNV((GLhalfNV)weight);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexWeighthv(Int16* weight)
            {
                    {
                        Delegates.glVertexWeighthvNV((GLhalfNV*)weight);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexWeighthv(GLhalfNV* weight)
            {
                unsafe { Delegates.glVertexWeighthvNV((GLhalfNV*)weight); }
            }
            
            public static 
            void VertexWeighthv(Int16[] weight)
            {
                unsafe
                {
                    fixed (Int16* weight_ptr = weight)
                    {
                        Delegates.glVertexWeighthvNV((GLhalfNV*)weight_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexWeighthv(GLhalfNV[] weight)
            {
                unsafe
                {
                    fixed (GLhalfNV* weight_ptr = weight)
                    {
                        Delegates.glVertexWeighthvNV((GLhalfNV*)weight_ptr);
                    }
                }
            }
            
            public static 
            void VertexWeighthv(ref Int16 weight)
            {
                unsafe
                {
                    fixed (Int16* weight_ptr = &weight)
                    {
                        Delegates.glVertexWeighthvNV((GLhalfNV*)weight_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexWeighthv(ref GLhalfNV weight)
            {
                unsafe
                {
                    fixed (GLhalfNV* weight_ptr = &weight)
                    {
                        Delegates.glVertexWeighthvNV((GLhalfNV*)weight_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1h(Int32 index, Int16 x)
            {
                Delegates.glVertexAttrib1hNV((GLuint)index, (GLhalfNV)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1h(GLuint index, GLhalfNV x)
            {
                Delegates.glVertexAttrib1hNV((GLuint)index, (GLhalfNV)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1hv(Int32 index, Int16* v)
            {
                    {
                        Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1hv(GLuint index, GLhalfNV* v)
            {
                unsafe { Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v); }
            }
            
            public static 
            void VertexAttrib1hv(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1hv(GLuint index, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib1hv(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1hv(GLuint index, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2h(Int32 index, Int16 x, Int16 y)
            {
                Delegates.glVertexAttrib2hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2h(GLuint index, GLhalfNV x, GLhalfNV y)
            {
                Delegates.glVertexAttrib2hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2hv(Int32 index, Int16* v)
            {
                    {
                        Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2hv(GLuint index, GLhalfNV* v)
            {
                unsafe { Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v); }
            }
            
            public static 
            void VertexAttrib2hv(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2hv(GLuint index, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib2hv(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2hv(GLuint index, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3h(Int32 index, Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertexAttrib3hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3h(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)
            {
                Delegates.glVertexAttrib3hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3hv(Int32 index, Int16* v)
            {
                    {
                        Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3hv(GLuint index, GLhalfNV* v)
            {
                unsafe { Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v); }
            }
            
            public static 
            void VertexAttrib3hv(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3hv(GLuint index, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib3hv(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3hv(GLuint index, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4h(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertexAttrib4hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z, (GLhalfNV)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4h(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
            {
                Delegates.glVertexAttrib4hNV((GLuint)index, (GLhalfNV)x, (GLhalfNV)y, (GLhalfNV)z, (GLhalfNV)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4hv(Int32 index, Int16* v)
            {
                    {
                        Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4hv(GLuint index, GLhalfNV* v)
            {
                unsafe { Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v); }
            }
            
            public static 
            void VertexAttrib4hv(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4hv(GLuint index, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttrib4hv(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4hv(GLuint index, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4hvNV((GLuint)index, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1hv(Int32 index, GLsizei n, Int16* v)
            {
                    {
                        Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1hv(GLuint index, GLsizei n, GLhalfNV* v)
            {
                unsafe { Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v); }
            }
            
            public static 
            void VertexAttribs1hv(Int32 index, GLsizei n, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1hv(GLuint index, GLsizei n, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs1hv(Int32 index, GLsizei n, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1hv(GLuint index, GLsizei n, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2hv(Int32 index, GLsizei n, Int16* v)
            {
                    {
                        Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2hv(GLuint index, GLsizei n, GLhalfNV* v)
            {
                unsafe { Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v); }
            }
            
            public static 
            void VertexAttribs2hv(Int32 index, GLsizei n, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2hv(GLuint index, GLsizei n, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs2hv(Int32 index, GLsizei n, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2hv(GLuint index, GLsizei n, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3hv(Int32 index, GLsizei n, Int16* v)
            {
                    {
                        Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3hv(GLuint index, GLsizei n, GLhalfNV* v)
            {
                unsafe { Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v); }
            }
            
            public static 
            void VertexAttribs3hv(Int32 index, GLsizei n, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3hv(GLuint index, GLsizei n, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs3hv(Int32 index, GLsizei n, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3hv(GLuint index, GLsizei n, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4hv(Int32 index, GLsizei n, Int16* v)
            {
                    {
                        Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4hv(GLuint index, GLsizei n, GLhalfNV* v)
            {
                unsafe { Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v); }
            }
            
            public static 
            void VertexAttribs4hv(Int32 index, GLsizei n, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4hv(GLuint index, GLsizei n, GLhalfNV[] v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            public static 
            void VertexAttribs4hv(Int32 index, GLsizei n, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4hv(GLuint index, GLsizei n, ref GLhalfNV v)
            {
                unsafe
                {
                    fixed (GLhalfNV* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4hvNV((GLuint)index, (GLsizei)n, (GLhalfNV*)v_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelDataRange(GL.Enums.NV_pixel_data_range target, GLsizei length, void* pointer)
            {
                unsafe { Delegates.glPixelDataRangeNV((GL.Enums.NV_pixel_data_range)target, (GLsizei)length, (void*)pointer); }
            }
            
            public static 
            void PixelDataRange(GL.Enums.NV_pixel_data_range target, GLsizei length, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glPixelDataRangeNV((GL.Enums.NV_pixel_data_range)target, (GLsizei)length, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void FlushPixelDataRange(GL.Enums.NV_pixel_data_range target)
            {
                Delegates.glFlushPixelDataRangeNV((GL.Enums.NV_pixel_data_range)target);
            }
            
            public static 
            void PrimitiveRestart()
            {
                Delegates.glPrimitiveRestartNV();
            }
            
            public static 
            void PrimitiveRestartIndex(Int32 index)
            {
                Delegates.glPrimitiveRestartIndexNV((GLuint)index);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void PrimitiveRestartIndex(GLuint index)
            {
                Delegates.glPrimitiveRestartIndexNV((GLuint)index);
            }
            
            public static 
            void ProgramLocalParameterI4i(GL.Enums.NV_gpu_program4 target, Int32 index, GLint x, GLint y, GLint z, GLint w)
            {
                Delegates.glProgramLocalParameterI4iNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4i(GL.Enums.NV_gpu_program4 target, GLuint index, GLint x, GLint y, GLint z, GLint w)
            {
                Delegates.glProgramLocalParameterI4iNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint* @params)
            {
                    {
                        Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint* @params)
            {
                unsafe { Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params); }
            }
            
            public static 
            void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, GLint* @params)
            {
                    {
                        Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint* @params)
            {
                unsafe { Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params); }
            }
            
            public static 
            void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParameterI4ui(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glProgramLocalParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4ui(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
            {
                Delegates.glProgramLocalParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
            {
                    {
                        Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint* @params)
            {
                unsafe { Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params); }
            }
            
            public static 
            void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, ref GLuint @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, Int32* @params)
            {
                    {
                        Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint* @params)
            {
                unsafe { Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params); }
            }
            
            public static 
            void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLuint @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParameterI4i(GL.Enums.NV_gpu_program4 target, Int32 index, GLint x, GLint y, GLint z, GLint w)
            {
                Delegates.glProgramEnvParameterI4iNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4i(GL.Enums.NV_gpu_program4 target, GLuint index, GLint x, GLint y, GLint z, GLint w)
            {
                Delegates.glProgramEnvParameterI4iNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint* @params)
            {
                    {
                        Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint* @params)
            {
                unsafe { Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params); }
            }
            
            public static 
            void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameterI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, GLint* @params)
            {
                    {
                        Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint* @params)
            {
                unsafe { Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params); }
            }
            
            public static 
            void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParametersI4iv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParametersI4ivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParameterI4ui(GL.Enums.NV_gpu_program4 target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glProgramEnvParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4ui(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
            {
                Delegates.glProgramEnvParameterI4uiNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint)x, (GLuint)y, (GLuint)z, (GLuint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
            {
                    {
                        Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint* @params)
            {
                unsafe { Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params); }
            }
            
            public static 
            void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, ref GLuint @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameterI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, Int32* @params)
            {
                    {
                        Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint* @params)
            {
                unsafe { Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params); }
            }
            
            public static 
            void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLsizei count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParametersI4uiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLuint @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParametersI4uivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint* @params)
            {
                unsafe { Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params); }
            }
            
            public static 
            void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
            {
                @params = default(Int32*);
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint* @params)
            {
                unsafe { Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params); }
            }
            
            public static 
            void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, out Int32 @params)
            {
                @params = default(Int32);
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, out GLuint @params)
            {
                @params = default(GLuint);
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint* @params)
            {
                unsafe { Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params); }
            }
            
            public static 
            void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, Int32 index, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterIiv(GL.Enums.NV_gpu_program4 target, GLuint index, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterIivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32* @params)
            {
                @params = default(Int32*);
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint* @params)
            {
                unsafe { Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params); }
            }
            
            public static 
            void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, Int32 index, out Int32 @params)
            {
                @params = default(Int32);
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterIuiv(GL.Enums.NV_gpu_program4 target, GLuint index, out GLuint @params)
            {
                @params = default(GLuint);
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((GL.Enums.NV_gpu_program4)target, (GLuint)index, (GLuint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void ProgramVertexLimit(GL.Enums.NV_geometry_program4 target, GLint limit)
            {
                Delegates.glProgramVertexLimitNV((GL.Enums.NV_geometry_program4)target, (GLint)limit);
            }
            
            public static 
            void DepthRanged(GLdouble zNear, GLdouble zFar)
            {
                Delegates.glDepthRangedNV((GLdouble)zNear, (GLdouble)zFar);
            }
            
            public static 
            void ClearDepthd(GLdouble depth)
            {
                Delegates.glClearDepthdNV((GLdouble)depth);
            }
            
            public static 
            void DepthBoundsd(GLdouble zmin, GLdouble zmax)
            {
                Delegates.glDepthBoundsdNV((GLdouble)zmin, (GLdouble)zmax);
            }
            
            public static 
            void RenderbufferStorageMultisampleCoverage(GL.Enums.NV_framebuffer_multisample_coverage target, GLsizei coverageSamples, GLsizei colorSamples, GL.Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height)
            {
                Delegates.glRenderbufferStorageMultisampleCoverageNV((GL.Enums.NV_framebuffer_multisample_coverage)target, (GLsizei)coverageSamples, (GLsizei)colorSamples, (GL.Enums.PixelInternalFormat)internalformat, (GLsizei)width, (GLsizei)height);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, GLfloat* @params)
            {
                    {
                        Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLfloat* @params)
            {
                unsafe { Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params); }
            }
            
            public static 
            void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersfv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLfloat @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersfvNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, GLint* @params)
            {
                    {
                        Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLint* @params)
            {
                unsafe { Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params); }
            }
            
            public static 
            void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersIiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLint @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersIivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, Int32* @params)
            {
                    {
                        Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLuint* @params)
            {
                unsafe { Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params); }
            }
            
            public static 
            void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLuint[] @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, Int32 buffer, Int32 index, GLsizei count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersIuiv(GL.Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLuint @params)
            {
                unsafe
                {
                    fixed (GLuint* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersIuivNV((GL.Enums.NV_parameter_buffer_object)target, (GLuint)buffer, (GLuint)index, (GLsizei)count, (GLuint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void BeginTransformFeedback(GL.Enums.NV_transform_feedback primitiveMode)
            {
                Delegates.glBeginTransformFeedbackNV((GL.Enums.NV_transform_feedback)primitiveMode);
            }
            
            public static 
            void EndTransformFeedback()
            {
                Delegates.glEndTransformFeedbackNV();
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TransformFeedbackAttribs(Int32 count, GLint* attribs, GL.Enums.NV_transform_feedback bufferMode)
            {
                    {
                        Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TransformFeedbackAttribs(GLuint count, GLint* attribs, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe { Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs, (GL.Enums.NV_transform_feedback)bufferMode); }
            }
            
            public static 
            void TransformFeedbackAttribs(Int32 count, GLint[] attribs, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe
                {
                    fixed (GLint* attribs_ptr = attribs)
                    {
                        Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TransformFeedbackAttribs(GLuint count, GLint[] attribs, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe
                {
                    fixed (GLint* attribs_ptr = attribs)
                    {
                        Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
                }
            }
            
            public static 
            void TransformFeedbackAttribs(Int32 count, ref GLint attribs, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe
                {
                    fixed (GLint* attribs_ptr = &attribs)
                    {
                        Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TransformFeedbackAttribs(GLuint count, ref GLint attribs, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe
                {
                    fixed (GLint* attribs_ptr = &attribs)
                    {
                        Delegates.glTransformFeedbackAttribsNV((GLuint)count, (GLint*)attribs_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
                }
            }
            
            public static 
            void BindBufferRange(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer, GLintptr offset, GLsizeiptr size)
            {
                Delegates.glBindBufferRangeNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer, (GLintptr)offset, (GLsizeiptr)size);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindBufferRange(GL.Enums.NV_transform_feedback target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
            {
                Delegates.glBindBufferRangeNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer, (GLintptr)offset, (GLsizeiptr)size);
            }
            
            public static 
            void BindBufferOffset(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer, GLintptr offset)
            {
                Delegates.glBindBufferOffsetNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer, (GLintptr)offset);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindBufferOffset(GL.Enums.NV_transform_feedback target, GLuint index, GLuint buffer, GLintptr offset)
            {
                Delegates.glBindBufferOffsetNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer, (GLintptr)offset);
            }
            
            public static 
            void BindBufferBase(GL.Enums.NV_transform_feedback target, Int32 index, Int32 buffer)
            {
                Delegates.glBindBufferBaseNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindBufferBase(GL.Enums.NV_transform_feedback target, GLuint index, GLuint buffer)
            {
                Delegates.glBindBufferBaseNV((GL.Enums.NV_transform_feedback)target, (GLuint)index, (GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TransformFeedbackVaryings(Int32 program, GLsizei count, GLint* locations, GL.Enums.NV_transform_feedback bufferMode)
            {
                    {
                        Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TransformFeedbackVaryings(GLuint program, GLsizei count, GLint* locations, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe { Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations, (GL.Enums.NV_transform_feedback)bufferMode); }
            }
            
            public static 
            void TransformFeedbackVaryings(Int32 program, GLsizei count, GLint[] locations, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe
                {
                    fixed (GLint* locations_ptr = locations)
                    {
                        Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TransformFeedbackVaryings(GLuint program, GLsizei count, GLint[] locations, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe
                {
                    fixed (GLint* locations_ptr = locations)
                    {
                        Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
                }
            }
            
            public static 
            void TransformFeedbackVaryings(Int32 program, GLsizei count, ref GLint locations, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe
                {
                    fixed (GLint* locations_ptr = &locations)
                    {
                        Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void TransformFeedbackVaryings(GLuint program, GLsizei count, ref GLint locations, GL.Enums.NV_transform_feedback bufferMode)
            {
                unsafe
                {
                    fixed (GLint* locations_ptr = &locations)
                    {
                        Delegates.glTransformFeedbackVaryingsNV((GLuint)program, (GLsizei)count, (GLint*)locations_ptr, (GL.Enums.NV_transform_feedback)bufferMode);
                    }
                }
            }
            
            public static 
            void ActiveVarying(Int32 program, System.String name)
            {
                Delegates.glActiveVaryingNV((GLuint)program, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ActiveVarying(GLuint program, System.String name)
            {
                Delegates.glActiveVaryingNV((GLuint)program, (System.String)name);
            }
            
            public static 
            GLint GetVaryingLocation(Int32 program, System.String name)
            {
                return Delegates.glGetVaryingLocationNV((GLuint)program, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLint GetVaryingLocation(GLuint program, System.String name)
            {
                return Delegates.glGetVaryingLocationNV((GLuint)program, (System.String)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                unsafe { Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = &size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = &size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei* length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei*);
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                size = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                size = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                    }
            }
            
            public static 
            void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }
            
            public static 
            void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = &size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = &size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
            }
            
            public static 
            void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                size = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                size = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, GLsizei[] length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = length)
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei* size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei* size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei* size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei*);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
            }
            
            public static 
            void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = &size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, GL.Enums.NV_transform_feedback* type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback*);
                name = default(System.Text.StringBuilder);
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = &size)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
            }
            
            public static 
            void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, GL.Enums.NV_transform_feedback[] type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                    }
                }
            }
            
            public static 
            void GetActiveVarying(Int32 program, Int32 index, GLsizei bufSize, out GLsizei length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, out GL.Enums.NV_transform_feedback type, System.Text.StringBuilder name)
            {
                length = default(GLsizei);
                size = default(GLsizei);
                type = default(GL.Enums.NV_transform_feedback);
                name = default(System.Text.StringBuilder);
                unsafe
                {
                    fixed (GLsizei* length_ptr = &length)
                    fixed (GLsizei* size_ptr = &size)
                    fixed (GL.Enums.NV_transform_feedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((GLuint)program, (GLuint)index, (GLsizei)bufSize, (GLsizei*)length_ptr, (GLsizei*)size_ptr, (GL.Enums.NV_transform_feedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTransformFeedbackVarying(Int32 program, Int32 index, GLint* location)
            {
                location = default(GLint*);
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTransformFeedbackVarying(GLuint program, GLuint index, GLint* location)
            {
                unsafe { Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location); }
            }
            
            public static 
            void GetTransformFeedbackVarying(Int32 program, Int32 index, GLint[] location)
            {
                unsafe
                {
                    fixed (GLint* location_ptr = location)
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetTransformFeedbackVarying(GLuint program, GLuint index, GLint[] location)
            {
                unsafe
                {
                    fixed (GLint* location_ptr = location)
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location_ptr);
                    }
                }
            }
            
            public static 
            void GetTransformFeedbackVarying(Int32 program, Int32 index, out GLint location)
            {
                location = default(GLint);
                unsafe
                {
                    fixed (GLint* location_ptr = &location)
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location_ptr);
                        location = *location_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetTransformFeedbackVarying(GLuint program, GLuint index, out GLint location)
            {
                location = default(GLint);
                unsafe
                {
                    fixed (GLint* location_ptr = &location)
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((GLuint)program, (GLuint)index, (GLint*)location_ptr);
                        location = *location_ptr;
                    }
                }
            }
            
        }

        public static class MESA
        {
            public static 
            void ResizeBuffers()
            {
                Delegates.glResizeBuffersMESA();
            }
            
            public static 
            void WindowPos2d(GLdouble x, GLdouble y)
            {
                Delegates.glWindowPos2dMESA((GLdouble)x, (GLdouble)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2dv(GLdouble* v)
            {
                unsafe { Delegates.glWindowPos2dvMESA((GLdouble*)v); }
            }
            
            public static 
            void WindowPos2dv(GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glWindowPos2dvMESA((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2dv(ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glWindowPos2dvMESA((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2f(GLfloat x, GLfloat y)
            {
                Delegates.glWindowPos2fMESA((GLfloat)x, (GLfloat)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2fv(GLfloat* v)
            {
                unsafe { Delegates.glWindowPos2fvMESA((GLfloat*)v); }
            }
            
            public static 
            void WindowPos2fv(GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glWindowPos2fvMESA((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2fv(ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glWindowPos2fvMESA((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2i(GLint x, GLint y)
            {
                Delegates.glWindowPos2iMESA((GLint)x, (GLint)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2iv(GLint* v)
            {
                unsafe { Delegates.glWindowPos2ivMESA((GLint*)v); }
            }
            
            public static 
            void WindowPos2iv(GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glWindowPos2ivMESA((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2iv(ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glWindowPos2ivMESA((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2s(GLshort x, GLshort y)
            {
                Delegates.glWindowPos2sMESA((GLshort)x, (GLshort)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2sv(GLshort* v)
            {
                unsafe { Delegates.glWindowPos2svMESA((GLshort*)v); }
            }
            
            public static 
            void WindowPos2sv(GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glWindowPos2svMESA((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos2sv(ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glWindowPos2svMESA((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
            {
                Delegates.glWindowPos3dMESA((GLdouble)x, (GLdouble)y, (GLdouble)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3dv(GLdouble* v)
            {
                unsafe { Delegates.glWindowPos3dvMESA((GLdouble*)v); }
            }
            
            public static 
            void WindowPos3dv(GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glWindowPos3dvMESA((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3dv(ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glWindowPos3dvMESA((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glWindowPos3fMESA((GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3fv(GLfloat* v)
            {
                unsafe { Delegates.glWindowPos3fvMESA((GLfloat*)v); }
            }
            
            public static 
            void WindowPos3fv(GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glWindowPos3fvMESA((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3fv(ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glWindowPos3fvMESA((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3i(GLint x, GLint y, GLint z)
            {
                Delegates.glWindowPos3iMESA((GLint)x, (GLint)y, (GLint)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3iv(GLint* v)
            {
                unsafe { Delegates.glWindowPos3ivMESA((GLint*)v); }
            }
            
            public static 
            void WindowPos3iv(GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glWindowPos3ivMESA((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3iv(ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glWindowPos3ivMESA((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3s(GLshort x, GLshort y, GLshort z)
            {
                Delegates.glWindowPos3sMESA((GLshort)x, (GLshort)y, (GLshort)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3sv(GLshort* v)
            {
                unsafe { Delegates.glWindowPos3svMESA((GLshort*)v); }
            }
            
            public static 
            void WindowPos3sv(GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glWindowPos3svMESA((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos3sv(ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glWindowPos3svMESA((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glWindowPos4dMESA((GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos4dv(GLdouble* v)
            {
                unsafe { Delegates.glWindowPos4dvMESA((GLdouble*)v); }
            }
            
            public static 
            void WindowPos4dv(GLdouble[] v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = v)
                    {
                        Delegates.glWindowPos4dvMESA((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos4dv(ref GLdouble v)
            {
                unsafe
                {
                    fixed (GLdouble* v_ptr = &v)
                    {
                        Delegates.glWindowPos4dvMESA((GLdouble*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glWindowPos4fMESA((GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos4fv(GLfloat* v)
            {
                unsafe { Delegates.glWindowPos4fvMESA((GLfloat*)v); }
            }
            
            public static 
            void WindowPos4fv(GLfloat[] v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = v)
                    {
                        Delegates.glWindowPos4fvMESA((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos4fv(ref GLfloat v)
            {
                unsafe
                {
                    fixed (GLfloat* v_ptr = &v)
                    {
                        Delegates.glWindowPos4fvMESA((GLfloat*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos4i(GLint x, GLint y, GLint z, GLint w)
            {
                Delegates.glWindowPos4iMESA((GLint)x, (GLint)y, (GLint)z, (GLint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos4iv(GLint* v)
            {
                unsafe { Delegates.glWindowPos4ivMESA((GLint*)v); }
            }
            
            public static 
            void WindowPos4iv(GLint[] v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = v)
                    {
                        Delegates.glWindowPos4ivMESA((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos4iv(ref GLint v)
            {
                unsafe
                {
                    fixed (GLint* v_ptr = &v)
                    {
                        Delegates.glWindowPos4ivMESA((GLint*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
            {
                Delegates.glWindowPos4sMESA((GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos4sv(GLshort* v)
            {
                unsafe { Delegates.glWindowPos4svMESA((GLshort*)v); }
            }
            
            public static 
            void WindowPos4sv(GLshort[] v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = v)
                    {
                        Delegates.glWindowPos4svMESA((GLshort*)v_ptr);
                    }
                }
            }
            
            public static 
            void WindowPos4sv(ref GLshort v)
            {
                unsafe
                {
                    fixed (GLshort* v_ptr = &v)
                    {
                        Delegates.glWindowPos4svMESA((GLshort*)v_ptr);
                    }
                }
            }
            
        }

        public static class IBM
        {
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint* first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                unsafe { Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint* first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint* first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint[] first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                    fixed (GLint* first_ptr = first)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, ref GLint first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                    fixed (GLint* first_ptr = &first)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode* mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint* first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint* first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint* first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint[] first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLint* first_ptr = first)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            public static 
            void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
                }
            }
            
            public static 
            void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, ref GLint first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLint* first_ptr = &first)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            public static 
            void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
                }
            }
            
            public static 
            void MultiModeDrawArrays(GL.Enums.BeginMode[] mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint* first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint* first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint* first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint[] first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLint* first_ptr = first)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            public static 
            void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
                }
            }
            
            public static 
            void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, ref GLint first, GLsizei* count, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLint* first_ptr = &first)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            public static 
            void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
            {
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
                }
            }
            
            public static 
            void MultiModeDrawArrays(ref GL.Enums.BeginMode mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
            {
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((GL.Enums.BeginMode*)mode_ptr, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount, (GLint)modestride);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                unsafe { Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    fixed (GLsizei* count_ptr = count)
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode* mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    fixed (GLsizei* count_ptr = &count)
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode[] mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode[] mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode[] mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            public static 
            void MultiModeDrawElements(GL.Enums.BeginMode[] mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLsizei* count_ptr = count)
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(GL.Enums.BeginMode[] mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            public static 
            void MultiModeDrawElements(GL.Enums.BeginMode[] mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = mode)
                    fixed (GLsizei* count_ptr = &count)
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(ref GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(ref GL.Enums.BeginMode mode, GLsizei* count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(ref GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            public static 
            void MultiModeDrawElements(ref GL.Enums.BeginMode mode, GLsizei[] count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLsizei* count_ptr = count)
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(ref GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, void* indices, GLsizei primcount, GLint modestride)
            {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices, (GLsizei)primcount, (GLint)modestride);
                    }
            }
            
            public static 
            void MultiModeDrawElements(ref GL.Enums.BeginMode mode, ref GLsizei count, GL.Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    fixed (GL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (GLsizei* count_ptr = &count)
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((GL.Enums.BeginMode*)mode_ptr, (GLsizei*)count_ptr, (GL.Enums.IBM_multimode_draw_arrays)type, (void*)indices_ptr.AddrOfPinnedObject(), (GLsizei)primcount, (GLint)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorPointerList(GLint size, GL.Enums.ColorPointerType type, GLint stride, void* pointer, GLint ptrstride)
            {
                unsafe { Delegates.glColorPointerListIBM((GLint)size, (GL.Enums.ColorPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
            }
            
            public static 
            void ColorPointerList(GLint size, GL.Enums.ColorPointerType type, GLint stride, object pointer, GLint ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glColorPointerListIBM((GLint)size, (GL.Enums.ColorPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColorPointerList(GLint size, GL.Enums.IBM_vertex_array_lists type, GLint stride, void* pointer, GLint ptrstride)
            {
                unsafe { Delegates.glSecondaryColorPointerListIBM((GLint)size, (GL.Enums.IBM_vertex_array_lists)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
            }
            
            public static 
            void SecondaryColorPointerList(GLint size, GL.Enums.IBM_vertex_array_lists type, GLint stride, object pointer, GLint ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glSecondaryColorPointerListIBM((GLint)size, (GL.Enums.IBM_vertex_array_lists)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void EdgeFlagPointerList(GLint stride, GLboolean* pointer, GLint ptrstride)
            {
                unsafe { Delegates.glEdgeFlagPointerListIBM((GLint)stride, (GLboolean*)pointer, (GLint)ptrstride); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordPointerList(GL.Enums.IBM_vertex_array_lists type, GLint stride, void* pointer, GLint ptrstride)
            {
                unsafe { Delegates.glFogCoordPointerListIBM((GL.Enums.IBM_vertex_array_lists)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
            }
            
            public static 
            void FogCoordPointerList(GL.Enums.IBM_vertex_array_lists type, GLint stride, object pointer, GLint ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glFogCoordPointerListIBM((GL.Enums.IBM_vertex_array_lists)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void IndexPointerList(GL.Enums.IndexPointerType type, GLint stride, void* pointer, GLint ptrstride)
            {
                unsafe { Delegates.glIndexPointerListIBM((GL.Enums.IndexPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
            }
            
            public static 
            void IndexPointerList(GL.Enums.IndexPointerType type, GLint stride, object pointer, GLint ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glIndexPointerListIBM((GL.Enums.IndexPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalPointerList(GL.Enums.NormalPointerType type, GLint stride, void* pointer, GLint ptrstride)
            {
                unsafe { Delegates.glNormalPointerListIBM((GL.Enums.NormalPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
            }
            
            public static 
            void NormalPointerList(GL.Enums.NormalPointerType type, GLint stride, object pointer, GLint ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glNormalPointerListIBM((GL.Enums.NormalPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoordPointerList(GLint size, GL.Enums.TexCoordPointerType type, GLint stride, void* pointer, GLint ptrstride)
            {
                unsafe { Delegates.glTexCoordPointerListIBM((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
            }
            
            public static 
            void TexCoordPointerList(GLint size, GL.Enums.TexCoordPointerType type, GLint stride, object pointer, GLint ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glTexCoordPointerListIBM((GLint)size, (GL.Enums.TexCoordPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexPointerList(GLint size, GL.Enums.VertexPointerType type, GLint stride, void* pointer, GLint ptrstride)
            {
                unsafe { Delegates.glVertexPointerListIBM((GLint)size, (GL.Enums.VertexPointerType)type, (GLint)stride, (void*)pointer, (GLint)ptrstride); }
            }
            
            public static 
            void VertexPointerList(GLint size, GL.Enums.VertexPointerType type, GLint stride, object pointer, GLint ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexPointerListIBM((GLint)size, (GL.Enums.VertexPointerType)type, (GLint)stride, (void*)pointer_ptr.AddrOfPinnedObject(), (GLint)ptrstride);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
        }

        public static class ATI
        {
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, GLint* param)
            {
                unsafe { Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param); }
            }
            
            public static 
            void TexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, GLint[] param)
            {
                unsafe
                {
                    fixed (GLint* param_ptr = param)
                    {
                        Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param_ptr);
                    }
                }
            }
            
            public static 
            void TexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, ref GLint param)
            {
                unsafe
                {
                    fixed (GLint* param_ptr = &param)
                    {
                        Delegates.glTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void TexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, GLfloat* param)
            {
                unsafe { Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param); }
            }
            
            public static 
            void TexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, GLfloat[] param)
            {
                unsafe
                {
                    fixed (GLfloat* param_ptr = param)
                    {
                        Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param_ptr);
                    }
                }
            }
            
            public static 
            void TexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, ref GLfloat param)
            {
                unsafe
                {
                    fixed (GLfloat* param_ptr = &param)
                    {
                        Delegates.glTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, GLint* param)
            {
                unsafe { Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param); }
            }
            
            public static 
            void GetTexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, GLint[] param)
            {
                unsafe
                {
                    fixed (GLint* param_ptr = param)
                    {
                        Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param_ptr);
                    }
                }
            }
            
            public static 
            void GetTexBumpParameteriv(GL.Enums.ATI_envmap_bumpmap pname, out GLint param)
            {
                param = default(GLint);
                unsafe
                {
                    fixed (GLint* param_ptr = &param)
                    {
                        Delegates.glGetTexBumpParameterivATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLint*)param_ptr);
                        param = *param_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, GLfloat* param)
            {
                unsafe { Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param); }
            }
            
            public static 
            void GetTexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, GLfloat[] param)
            {
                unsafe
                {
                    fixed (GLfloat* param_ptr = param)
                    {
                        Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param_ptr);
                    }
                }
            }
            
            public static 
            void GetTexBumpParameterfv(GL.Enums.ATI_envmap_bumpmap pname, out GLfloat param)
            {
                param = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* param_ptr = &param)
                    {
                        Delegates.glGetTexBumpParameterfvATI((GL.Enums.ATI_envmap_bumpmap)pname, (GLfloat*)param_ptr);
                        param = *param_ptr;
                    }
                }
            }
            
            public static 
            Int32 GenFragmentShaders(Int32 range)
            {
                return Delegates.glGenFragmentShadersATI((GLuint)range);
            }
            
            [System.CLSCompliant(false)]
            public static 
            Int32 GenFragmentShaders(GLuint range)
            {
                return Delegates.glGenFragmentShadersATI((GLuint)range);
            }
            
            public static 
            void BindFragmentShader(Int32 id)
            {
                Delegates.glBindFragmentShaderATI((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindFragmentShader(GLuint id)
            {
                Delegates.glBindFragmentShaderATI((GLuint)id);
            }
            
            public static 
            void DeleteFragmentShader(Int32 id)
            {
                Delegates.glDeleteFragmentShaderATI((GLuint)id);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteFragmentShader(GLuint id)
            {
                Delegates.glDeleteFragmentShaderATI((GLuint)id);
            }
            
            public static 
            void BeginFragmentShader()
            {
                Delegates.glBeginFragmentShaderATI();
            }
            
            public static 
            void EndFragmentShader()
            {
                Delegates.glEndFragmentShaderATI();
            }
            
            public static 
            void PassTexCoord(Int32 dst, Int32 coord, GL.Enums.ATI_fragment_shader swizzle)
            {
                Delegates.glPassTexCoordATI((GLuint)dst, (GLuint)coord, (GL.Enums.ATI_fragment_shader)swizzle);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void PassTexCoord(GLuint dst, GLuint coord, GL.Enums.ATI_fragment_shader swizzle)
            {
                Delegates.glPassTexCoordATI((GLuint)dst, (GLuint)coord, (GL.Enums.ATI_fragment_shader)swizzle);
            }
            
            public static 
            void SampleMap(Int32 dst, Int32 interp, GL.Enums.ATI_fragment_shader swizzle)
            {
                Delegates.glSampleMapATI((GLuint)dst, (GLuint)interp, (GL.Enums.ATI_fragment_shader)swizzle);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SampleMap(GLuint dst, GLuint interp, GL.Enums.ATI_fragment_shader swizzle)
            {
                Delegates.glSampleMapATI((GLuint)dst, (GLuint)interp, (GL.Enums.ATI_fragment_shader)swizzle);
            }
            
            public static 
            void ColorFragmentOp1(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
            {
                Delegates.glColorFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ColorFragmentOp1(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
            {
                Delegates.glColorFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod);
            }
            
            public static 
            void ColorFragmentOp2(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod)
            {
                Delegates.glColorFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ColorFragmentOp2(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
            {
                Delegates.glColorFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod);
            }
            
            public static 
            void ColorFragmentOp3(GL.Enums.ATI_fragment_shader 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((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod, (GLuint)arg3, (GLuint)arg3Rep, (GLuint)arg3Mod);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ColorFragmentOp3(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
            {
                Delegates.glColorFragmentOp3ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMask, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod, (GLuint)arg3, (GLuint)arg3Rep, (GLuint)arg3Mod);
            }
            
            public static 
            void AlphaFragmentOp1(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
            {
                Delegates.glAlphaFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void AlphaFragmentOp1(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
            {
                Delegates.glAlphaFragmentOp1ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod);
            }
            
            public static 
            void AlphaFragmentOp2(GL.Enums.ATI_fragment_shader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod)
            {
                Delegates.glAlphaFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void AlphaFragmentOp2(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
            {
                Delegates.glAlphaFragmentOp2ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod);
            }
            
            public static 
            void AlphaFragmentOp3(GL.Enums.ATI_fragment_shader 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((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod, (GLuint)arg3, (GLuint)arg3Rep, (GLuint)arg3Mod);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void AlphaFragmentOp3(GL.Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
            {
                Delegates.glAlphaFragmentOp3ATI((GL.Enums.ATI_fragment_shader)op, (GLuint)dst, (GLuint)dstMod, (GLuint)arg1, (GLuint)arg1Rep, (GLuint)arg1Mod, (GLuint)arg2, (GLuint)arg2Rep, (GLuint)arg2Mod, (GLuint)arg3, (GLuint)arg3Rep, (GLuint)arg3Mod);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SetFragmentShaderConstant(Int32 dst, GLfloat* value)
            {
                    {
                        Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void SetFragmentShaderConstant(GLuint dst, GLfloat* value)
            {
                unsafe { Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value); }
            }
            
            public static 
            void SetFragmentShaderConstant(Int32 dst, GLfloat[] value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = value)
                    {
                        Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SetFragmentShaderConstant(GLuint dst, GLfloat[] value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = value)
                    {
                        Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value_ptr);
                    }
                }
            }
            
            public static 
            void SetFragmentShaderConstant(Int32 dst, ref GLfloat value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = &value)
                    {
                        Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SetFragmentShaderConstant(GLuint dst, ref GLfloat value)
            {
                unsafe
                {
                    fixed (GLfloat* value_ptr = &value)
                    {
                        Delegates.glSetFragmentShaderConstantATI((GLuint)dst, (GLfloat*)value_ptr);
                    }
                }
            }
            
            public static 
            void PNTrianglesi(GL.Enums.ATI_pn_triangles pname, GLint param)
            {
                Delegates.glPNTrianglesiATI((GL.Enums.ATI_pn_triangles)pname, (GLint)param);
            }
            
            public static 
            void PNTrianglesf(GL.Enums.ATI_pn_triangles pname, GLfloat param)
            {
                Delegates.glPNTrianglesfATI((GL.Enums.ATI_pn_triangles)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe Int32 NewObjectBuffer(GLsizei size, void* pointer, GL.Enums.ATI_vertex_array_object usage)
            {
                unsafe { return Delegates.glNewObjectBufferATI((GLsizei)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)usage); }
            }
            
            public static 
            Int32 NewObjectBuffer(GLsizei size, object pointer, GL.Enums.ATI_vertex_array_object usage)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Int32 retval = Delegates.glNewObjectBufferATI((GLsizei)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)usage);
                        return retval;
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            GLboolean IsObjectBuffer(Int32 buffer)
            {
                return Delegates.glIsObjectBufferATI((GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsObjectBuffer(GLuint buffer)
            {
                return Delegates.glIsObjectBufferATI((GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void UpdateObjectBuffer(Int32 buffer, Int32 offset, GLsizei size, void* pointer, GL.Enums.ATI_vertex_array_object preserve)
            {
                    {
                        Delegates.glUpdateObjectBufferATI((GLuint)buffer, (GLuint)offset, (GLsizei)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)preserve);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void UpdateObjectBuffer(GLuint buffer, GLuint offset, GLsizei size, void* pointer, GL.Enums.ATI_vertex_array_object preserve)
            {
                unsafe { Delegates.glUpdateObjectBufferATI((GLuint)buffer, (GLuint)offset, (GLsizei)size, (void*)pointer, (GL.Enums.ATI_vertex_array_object)preserve); }
            }
            
            public static 
            void UpdateObjectBuffer(Int32 buffer, Int32 offset, GLsizei size, object pointer, GL.Enums.ATI_vertex_array_object preserve)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glUpdateObjectBufferATI((GLuint)buffer, (GLuint)offset, (GLsizei)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)preserve);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void UpdateObjectBuffer(GLuint buffer, GLuint offset, GLsizei size, object pointer, GL.Enums.ATI_vertex_array_object preserve)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glUpdateObjectBufferATI((GLuint)buffer, (GLuint)offset, (GLsizei)size, (void*)pointer_ptr.AddrOfPinnedObject(), (GL.Enums.ATI_vertex_array_object)preserve);
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectBufferfv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectBufferfv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetObjectBufferfv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetObjectBufferfv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetObjectBufferfv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetObjectBufferfv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectBufferfvATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectBufferiv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectBufferiv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
            {
                unsafe { Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params); }
            }
            
            public static 
            void GetObjectBufferiv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetObjectBufferiv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetObjectBufferiv(Int32 buffer, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetObjectBufferiv(GLuint buffer, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectBufferivATI((GLuint)buffer, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void FreeObjectBuffer(Int32 buffer)
            {
                Delegates.glFreeObjectBufferATI((GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FreeObjectBuffer(GLuint buffer)
            {
                Delegates.glFreeObjectBufferATI((GLuint)buffer);
            }
            
            public static 
            void ArrayObject(GL.Enums.EnableCap array, GLint size, GL.Enums.ATI_vertex_array_object type, GLsizei stride, Int32 buffer, Int32 offset)
            {
                Delegates.glArrayObjectATI((GL.Enums.EnableCap)array, (GLint)size, (GL.Enums.ATI_vertex_array_object)type, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void ArrayObject(GL.Enums.EnableCap array, GLint size, GL.Enums.ATI_vertex_array_object type, GLsizei stride, GLuint buffer, GLuint offset)
            {
                Delegates.glArrayObjectATI((GL.Enums.EnableCap)array, (GLint)size, (GL.Enums.ATI_vertex_array_object)type, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetArrayObjectfv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetArrayObjectfv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetArrayObjectfv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetArrayObjectfvATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetArrayObjectiv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
            {
                unsafe { Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params); }
            }
            
            public static 
            void GetArrayObjectiv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetArrayObjectiv(GL.Enums.EnableCap array, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetArrayObjectivATI((GL.Enums.EnableCap)array, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void VariantArrayObject(Int32 id, GL.Enums.ATI_vertex_array_object type, GLsizei stride, Int32 buffer, Int32 offset)
            {
                Delegates.glVariantArrayObjectATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)type, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VariantArrayObject(GLuint id, GL.Enums.ATI_vertex_array_object type, GLsizei stride, GLuint buffer, GLuint offset)
            {
                Delegates.glVariantArrayObjectATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)type, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantArrayObjectfv(Int32 id, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantArrayObjectfv(GLuint id, GL.Enums.ATI_vertex_array_object pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetVariantArrayObjectfv(Int32 id, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantArrayObjectfv(GLuint id, GL.Enums.ATI_vertex_array_object pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVariantArrayObjectfv(Int32 id, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantArrayObjectfv(GLuint id, GL.Enums.ATI_vertex_array_object pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetVariantArrayObjectfvATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantArrayObjectiv(Int32 id, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantArrayObjectiv(GLuint id, GL.Enums.ATI_vertex_array_object pname, GLint* @params)
            {
                unsafe { Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params); }
            }
            
            public static 
            void GetVariantArrayObjectiv(Int32 id, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantArrayObjectiv(GLuint id, GL.Enums.ATI_vertex_array_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVariantArrayObjectiv(Int32 id, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVariantArrayObjectiv(GLuint id, GL.Enums.ATI_vertex_array_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVariantArrayObjectivATI((GLuint)id, (GL.Enums.ATI_vertex_array_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            public static 
            void VertexStream1s(GL.Enums.ATI_vertex_streams stream, GLshort x)
            {
                Delegates.glVertexStream1sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream1sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
            {
                unsafe { Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
            }
            
            public static 
            void VertexStream1sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = coords)
                    {
                        Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream1sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream1svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream1i(GL.Enums.ATI_vertex_streams stream, GLint x)
            {
                Delegates.glVertexStream1iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream1iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
            {
                unsafe { Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
            }
            
            public static 
            void VertexStream1iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = coords)
                    {
                        Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream1iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream1ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream1f(GL.Enums.ATI_vertex_streams stream, GLfloat x)
            {
                Delegates.glVertexStream1fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream1fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
            {
                unsafe { Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
            }
            
            public static 
            void VertexStream1fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = coords)
                    {
                        Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream1fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream1fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream1d(GL.Enums.ATI_vertex_streams stream, GLdouble x)
            {
                Delegates.glVertexStream1dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)x);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream1dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
            {
                unsafe { Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
            }
            
            public static 
            void VertexStream1dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = coords)
                    {
                        Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream1dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream1dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream2s(GL.Enums.ATI_vertex_streams stream, GLshort x, GLshort y)
            {
                Delegates.glVertexStream2sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)x, (GLshort)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream2sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
            {
                unsafe { Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
            }
            
            public static 
            void VertexStream2sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = coords)
                    {
                        Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream2sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream2svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream2i(GL.Enums.ATI_vertex_streams stream, GLint x, GLint y)
            {
                Delegates.glVertexStream2iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)x, (GLint)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream2iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
            {
                unsafe { Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
            }
            
            public static 
            void VertexStream2iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = coords)
                    {
                        Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream2iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream2ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream2f(GL.Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y)
            {
                Delegates.glVertexStream2fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)x, (GLfloat)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream2fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
            {
                unsafe { Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
            }
            
            public static 
            void VertexStream2fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = coords)
                    {
                        Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream2fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream2fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream2d(GL.Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y)
            {
                Delegates.glVertexStream2dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)x, (GLdouble)y);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream2dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
            {
                unsafe { Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
            }
            
            public static 
            void VertexStream2dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = coords)
                    {
                        Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream2dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream2dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream3s(GL.Enums.ATI_vertex_streams stream, GLshort x, GLshort y, GLshort z)
            {
                Delegates.glVertexStream3sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)x, (GLshort)y, (GLshort)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream3sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
            {
                unsafe { Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
            }
            
            public static 
            void VertexStream3sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = coords)
                    {
                        Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream3sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream3i(GL.Enums.ATI_vertex_streams stream, GLint x, GLint y, GLint z)
            {
                Delegates.glVertexStream3iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)x, (GLint)y, (GLint)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream3iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
            {
                unsafe { Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
            }
            
            public static 
            void VertexStream3iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = coords)
                    {
                        Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream3iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream3f(GL.Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y, GLfloat z)
            {
                Delegates.glVertexStream3fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)x, (GLfloat)y, (GLfloat)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream3fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
            {
                unsafe { Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
            }
            
            public static 
            void VertexStream3fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = coords)
                    {
                        Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream3fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream3d(GL.Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y, GLdouble z)
            {
                Delegates.glVertexStream3dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)x, (GLdouble)y, (GLdouble)z);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream3dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
            {
                unsafe { Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
            }
            
            public static 
            void VertexStream3dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = coords)
                    {
                        Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream3dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream4s(GL.Enums.ATI_vertex_streams stream, GLshort x, GLshort y, GLshort z, GLshort w)
            {
                Delegates.glVertexStream4sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)x, (GLshort)y, (GLshort)z, (GLshort)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream4sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
            {
                unsafe { Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
            }
            
            public static 
            void VertexStream4sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = coords)
                    {
                        Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream4sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream4svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream4i(GL.Enums.ATI_vertex_streams stream, GLint x, GLint y, GLint z, GLint w)
            {
                Delegates.glVertexStream4iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)x, (GLint)y, (GLint)z, (GLint)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream4iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
            {
                unsafe { Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
            }
            
            public static 
            void VertexStream4iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = coords)
                    {
                        Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream4iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream4ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream4f(GL.Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
            {
                Delegates.glVertexStream4fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream4fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
            {
                unsafe { Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
            }
            
            public static 
            void VertexStream4fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = coords)
                    {
                        Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream4fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream4fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream4d(GL.Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
            {
                Delegates.glVertexStream4dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)x, (GLdouble)y, (GLdouble)z, (GLdouble)w);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream4dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
            {
                unsafe { Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
            }
            
            public static 
            void VertexStream4dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = coords)
                    {
                        Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void VertexStream4dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream4dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3b(GL.Enums.ATI_vertex_streams stream, Byte nx, Byte ny, Byte nz)
            {
                Delegates.glNormalStream3bATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte)nx, (GLbyte)ny, (GLbyte)nz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void NormalStream3b(GL.Enums.ATI_vertex_streams stream, GLbyte nx, GLbyte ny, GLbyte nz)
            {
                Delegates.glNormalStream3bATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte)nx, (GLbyte)ny, (GLbyte)nz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, Byte* coords)
            {
                    {
                        Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, GLbyte* coords)
            {
                unsafe { Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords); }
            }
            
            public static 
            void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, Byte[] coords)
            {
                unsafe
                {
                    fixed (Byte* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, GLbyte[] coords)
            {
                unsafe
                {
                    fixed (GLbyte* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, ref Byte coords)
            {
                unsafe
                {
                    fixed (Byte* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void NormalStream3bv(GL.Enums.ATI_vertex_streams stream, ref GLbyte coords)
            {
                unsafe
                {
                    fixed (GLbyte* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3bvATI((GL.Enums.ATI_vertex_streams)stream, (GLbyte*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3s(GL.Enums.ATI_vertex_streams stream, GLshort nx, GLshort ny, GLshort nz)
            {
                Delegates.glNormalStream3sATI((GL.Enums.ATI_vertex_streams)stream, (GLshort)nx, (GLshort)ny, (GLshort)nz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3sv(GL.Enums.ATI_vertex_streams stream, GLshort* coords)
            {
                unsafe { Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords); }
            }
            
            public static 
            void NormalStream3sv(GL.Enums.ATI_vertex_streams stream, GLshort[] coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3sv(GL.Enums.ATI_vertex_streams stream, ref GLshort coords)
            {
                unsafe
                {
                    fixed (GLshort* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3svATI((GL.Enums.ATI_vertex_streams)stream, (GLshort*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3i(GL.Enums.ATI_vertex_streams stream, GLint nx, GLint ny, GLint nz)
            {
                Delegates.glNormalStream3iATI((GL.Enums.ATI_vertex_streams)stream, (GLint)nx, (GLint)ny, (GLint)nz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3iv(GL.Enums.ATI_vertex_streams stream, GLint* coords)
            {
                unsafe { Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords); }
            }
            
            public static 
            void NormalStream3iv(GL.Enums.ATI_vertex_streams stream, GLint[] coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3iv(GL.Enums.ATI_vertex_streams stream, ref GLint coords)
            {
                unsafe
                {
                    fixed (GLint* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3ivATI((GL.Enums.ATI_vertex_streams)stream, (GLint*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3f(GL.Enums.ATI_vertex_streams stream, GLfloat nx, GLfloat ny, GLfloat nz)
            {
                Delegates.glNormalStream3fATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat)nx, (GLfloat)ny, (GLfloat)nz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3fv(GL.Enums.ATI_vertex_streams stream, GLfloat* coords)
            {
                unsafe { Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords); }
            }
            
            public static 
            void NormalStream3fv(GL.Enums.ATI_vertex_streams stream, GLfloat[] coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3fv(GL.Enums.ATI_vertex_streams stream, ref GLfloat coords)
            {
                unsafe
                {
                    fixed (GLfloat* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3fvATI((GL.Enums.ATI_vertex_streams)stream, (GLfloat*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3d(GL.Enums.ATI_vertex_streams stream, GLdouble nx, GLdouble ny, GLdouble nz)
            {
                Delegates.glNormalStream3dATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble)nx, (GLdouble)ny, (GLdouble)nz);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3dv(GL.Enums.ATI_vertex_streams stream, GLdouble* coords)
            {
                unsafe { Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords); }
            }
            
            public static 
            void NormalStream3dv(GL.Enums.ATI_vertex_streams stream, GLdouble[] coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void NormalStream3dv(GL.Enums.ATI_vertex_streams stream, ref GLdouble coords)
            {
                unsafe
                {
                    fixed (GLdouble* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3dvATI((GL.Enums.ATI_vertex_streams)stream, (GLdouble*)coords_ptr);
                    }
                }
            }
            
            public static 
            void ClientActiveVertexStream(GL.Enums.ATI_vertex_streams stream)
            {
                Delegates.glClientActiveVertexStreamATI((GL.Enums.ATI_vertex_streams)stream);
            }
            
            public static 
            void VertexBlendEnvi(GL.Enums.ATI_vertex_streams pname, GLint param)
            {
                Delegates.glVertexBlendEnviATI((GL.Enums.ATI_vertex_streams)pname, (GLint)param);
            }
            
            public static 
            void VertexBlendEnvf(GL.Enums.ATI_vertex_streams pname, GLfloat param)
            {
                Delegates.glVertexBlendEnvfATI((GL.Enums.ATI_vertex_streams)pname, (GLfloat)param);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void ElementPointer(GL.Enums.ATI_element_array type, void* pointer)
            {
                unsafe { Delegates.glElementPointerATI((GL.Enums.ATI_element_array)type, (void*)pointer); }
            }
            
            public static 
            void ElementPointer(GL.Enums.ATI_element_array type, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glElementPointerATI((GL.Enums.ATI_element_array)type, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void DrawElementArray(GL.Enums.BeginMode mode, GLsizei count)
            {
                Delegates.glDrawElementArrayATI((GL.Enums.BeginMode)mode, (GLsizei)count);
            }
            
            public static 
            void DrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLsizei count)
            {
                Delegates.glDrawRangeElementArrayATI((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count)
            {
                Delegates.glDrawRangeElementArrayATI((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLsizei)count);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DrawBuffers(GLsizei n, GL.Enums.ATI_draw_buffers* bufs)
            {
                unsafe { Delegates.glDrawBuffersATI((GLsizei)n, (GL.Enums.ATI_draw_buffers*)bufs); }
            }
            
            public static 
            void DrawBuffers(GLsizei n, GL.Enums.ATI_draw_buffers[] bufs)
            {
                unsafe
                {
                    fixed (GL.Enums.ATI_draw_buffers* bufs_ptr = bufs)
                    {
                        Delegates.glDrawBuffersATI((GLsizei)n, (GL.Enums.ATI_draw_buffers*)bufs_ptr);
                    }
                }
            }
            
            public static 
            void DrawBuffers(GLsizei n, ref GL.Enums.ATI_draw_buffers bufs)
            {
                unsafe
                {
                    fixed (GL.Enums.ATI_draw_buffers* bufs_ptr = &bufs)
                    {
                        Delegates.glDrawBuffersATI((GLsizei)n, (GL.Enums.ATI_draw_buffers*)bufs_ptr);
                    }
                }
            }
            
            public static 
            IntPtr MapObjectBuffer(Int32 buffer)
            {
                unsafe
                {
                    {
                        IntPtr retval = Delegates.glMapObjectBufferATI((GLuint)buffer);
                        return retval;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            IntPtr MapObjectBuffer(GLuint buffer)
            {
                 return Delegates.glMapObjectBufferATI((GLuint)buffer); 
            }
            
            public static 
            void UnmapObjectBuffer(Int32 buffer)
            {
                Delegates.glUnmapObjectBufferATI((GLuint)buffer);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void UnmapObjectBuffer(GLuint buffer)
            {
                Delegates.glUnmapObjectBufferATI((GLuint)buffer);
            }
            
            public static 
            void StencilOpSeparate(GL.Enums.ATI_separate_stencil face, GL.Enums.StencilOp sfail, GL.Enums.StencilOp dpfail, GL.Enums.StencilOp dppass)
            {
                Delegates.glStencilOpSeparateATI((GL.Enums.ATI_separate_stencil)face, (GL.Enums.StencilOp)sfail, (GL.Enums.StencilOp)dpfail, (GL.Enums.StencilOp)dppass);
            }
            
            public static 
            void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, GLint @ref, Int32 mask)
            {
                Delegates.glStencilFuncSeparateATI((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (GLint)@ref, (GLuint)mask);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void StencilFuncSeparate(GL.Enums.StencilFunction frontfunc, GL.Enums.StencilFunction backfunc, GLint @ref, GLuint mask)
            {
                Delegates.glStencilFuncSeparateATI((GL.Enums.StencilFunction)frontfunc, (GL.Enums.StencilFunction)backfunc, (GLint)@ref, (GLuint)mask);
            }
            
            public static 
            void VertexAttribArrayObject(Int32 index, GLint size, GL.Enums.ATI_vertex_attrib_array_object type, GL.Enums.Boolean normalized, GLsizei stride, Int32 buffer, Int32 offset)
            {
                unsafe
                {
                    {
                        Delegates.glVertexAttribArrayObjectATI((GLuint)index, (GLint)size, (GL.Enums.ATI_vertex_attrib_array_object)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (GLuint)buffer, (GLuint)offset);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void VertexAttribArrayObject(GLuint index, GLint size, GL.Enums.ATI_vertex_attrib_array_object type, GL.Enums.Boolean normalized, GLsizei stride, GLuint buffer, GLuint offset)
            {
                 Delegates.glVertexAttribArrayObjectATI((GLuint)index, (GLint)size, (GL.Enums.ATI_vertex_attrib_array_object)type, (GL.Enums.Boolean)normalized, (GLsizei)stride, (GLuint)buffer, (GLuint)offset); 
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribArrayObjectfv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, GLfloat* @params)
            {
                @params = default(GLfloat*);
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribArrayObjectfv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, GLfloat* @params)
            {
                unsafe { Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params); }
            }
            
            public static 
            void GetVertexAttribArrayObjectfv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribArrayObjectfv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, GLfloat[] @params)
            {
                unsafe
                {
                    fixed (GLfloat* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribArrayObjectfv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribArrayObjectfv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, out GLfloat @params)
            {
                @params = default(GLfloat);
                unsafe
                {
                    fixed (GLfloat* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLfloat*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribArrayObjectiv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, GLint* @params)
            {
                @params = default(GLint*);
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribArrayObjectiv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, GLint* @params)
            {
                unsafe { Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params); }
            }
            
            public static 
            void GetVertexAttribArrayObjectiv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribArrayObjectiv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, GLint[] @params)
            {
                unsafe
                {
                    fixed (GLint* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params_ptr);
                    }
                }
            }
            
            public static 
            void GetVertexAttribArrayObjectiv(Int32 index, GL.Enums.ATI_vertex_attrib_array_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribArrayObjectiv(GLuint index, GL.Enums.ATI_vertex_attrib_array_object pname, out GLint @params)
            {
                @params = default(GLint);
                unsafe
                {
                    fixed (GLint* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((GLuint)index, (GL.Enums.ATI_vertex_attrib_array_object)pname, (GLint*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }
            
        }

        public static class APPLE
        {
            [System.CLSCompliant(false)]
            public static 
            unsafe void ElementPointer(GL.Enums.APPLE_element_array type, void* pointer)
            {
                unsafe { Delegates.glElementPointerAPPLE((GL.Enums.APPLE_element_array)type, (void*)pointer); }
            }
            
            public static 
            void ElementPointer(GL.Enums.APPLE_element_array type, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glElementPointerAPPLE((GL.Enums.APPLE_element_array)type, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void DrawElementArray(GL.Enums.BeginMode mode, GLint first, GLsizei count)
            {
                Delegates.glDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint)first, (GLsizei)count);
            }
            
            public static 
            void DrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint first, GLsizei count)
            {
                Delegates.glDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint)first, (GLsizei)count);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint first, GLsizei count)
            {
                Delegates.glDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint)first, (GLsizei)count);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint* first, GLsizei* count, GLsizei primcount)
            {
                unsafe { Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count, (GLsizei)primcount); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint* first, GLsizei[] count, GLsizei primcount)
            {
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint* first, ref GLsizei count, GLsizei primcount)
            {
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint[] first, GLsizei* count, GLsizei primcount)
            {
                    fixed (GLint* first_ptr = first)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                    }
            }
            
            public static 
            void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            public static 
            void MultiDrawElementArray(GL.Enums.BeginMode mode, GLint[] first, ref GLsizei count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElementArray(GL.Enums.BeginMode mode, ref GLint first, GLsizei* count, GLsizei primcount)
            {
                    fixed (GLint* first_ptr = &first)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                    }
            }
            
            public static 
            void MultiDrawElementArray(GL.Enums.BeginMode mode, ref GLint first, GLsizei[] count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            public static 
            void MultiDrawElementArray(GL.Enums.BeginMode mode, ref GLint first, ref GLsizei count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint* first, GLsizei* count, GLsizei primcount)
            {
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint* first, GLsizei* count, GLsizei primcount)
            {
                unsafe { Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count, (GLsizei)primcount); }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint* first, GLsizei[] count, GLsizei primcount)
            {
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint* first, GLsizei[] count, GLsizei primcount)
            {
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint* first, ref GLsizei count, GLsizei primcount)
            {
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint* first, ref GLsizei count, GLsizei primcount)
            {
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint[] first, GLsizei* count, GLsizei primcount)
            {
                    fixed (GLint* first_ptr = first)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei* count, GLsizei primcount)
            {
                    fixed (GLint* first_ptr = first)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                    }
            }
            
            public static 
            void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint[] first, GLsizei[] count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei[] count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            public static 
            void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, GLint[] first, ref GLsizei count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, ref GLsizei count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref GLint first, GLsizei* count, GLsizei primcount)
            {
                    fixed (GLint* first_ptr = &first)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, GLsizei* count, GLsizei primcount)
            {
                    fixed (GLint* first_ptr = &first)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count, (GLsizei)primcount);
                    }
            }
            
            public static 
            void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref GLint first, GLsizei[] count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, GLsizei[] count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            public static 
            void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, Int32 start, Int32 end, ref GLint first, ref GLsizei count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void MultiDrawRangeElementArray(GL.Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, ref GLsizei count, GLsizei primcount)
            {
                unsafe
                {
                    fixed (GLint* first_ptr = &first)
                    fixed (GLsizei* count_ptr = &count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((GL.Enums.BeginMode)mode, (GLuint)start, (GLuint)end, (GLint*)first_ptr, (GLsizei*)count_ptr, (GLsizei)primcount);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFences(GLsizei n, Int32* fences)
            {
                fences = default(Int32*);
                    {
                        Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFences(GLsizei n, GLuint* fences)
            {
                unsafe { Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences); }
            }
            
            public static 
            void GenFences(GLsizei n, Int32[] fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = fences)
                    {
                        Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenFences(GLsizei n, GLuint[] fences)
            {
                unsafe
                {
                    fixed (GLuint* fences_ptr = fences)
                    {
                        Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            public static 
            void GenFences(GLsizei n, out Int32 fences)
            {
                fences = default(Int32);
                unsafe
                {
                    fixed (Int32* fences_ptr = &fences)
                    {
                        Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
                        fences = *fences_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenFences(GLsizei n, out GLuint fences)
            {
                fences = default(GLuint);
                unsafe
                {
                    fixed (GLuint* fences_ptr = &fences)
                    {
                        Delegates.glGenFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
                        fences = *fences_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFences(GLsizei n, Int32* fences)
            {
                    {
                        Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFences(GLsizei n, GLuint* fences)
            {
                unsafe { Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences); }
            }
            
            public static 
            void DeleteFences(GLsizei n, Int32[] fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = fences)
                    {
                        Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteFences(GLsizei n, GLuint[] fences)
            {
                unsafe
                {
                    fixed (GLuint* fences_ptr = fences)
                    {
                        Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            public static 
            void DeleteFences(GLsizei n, ref Int32 fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = &fences)
                    {
                        Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteFences(GLsizei n, ref GLuint fences)
            {
                unsafe
                {
                    fixed (GLuint* fences_ptr = &fences)
                    {
                        Delegates.glDeleteFencesAPPLE((GLsizei)n, (GLuint*)fences_ptr);
                    }
                }
            }
            
            public static 
            void SetFence(Int32 fence)
            {
                Delegates.glSetFenceAPPLE((GLuint)fence);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void SetFence(GLuint fence)
            {
                Delegates.glSetFenceAPPLE((GLuint)fence);
            }
            
            public static 
            GLboolean IsFence(Int32 fence)
            {
                return Delegates.glIsFenceAPPLE((GLuint)fence);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsFence(GLuint fence)
            {
                return Delegates.glIsFenceAPPLE((GLuint)fence);
            }
            
            public static 
            GLboolean TestFence(Int32 fence)
            {
                return Delegates.glTestFenceAPPLE((GLuint)fence);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean TestFence(GLuint fence)
            {
                return Delegates.glTestFenceAPPLE((GLuint)fence);
            }
            
            public static 
            void FinishFence(Int32 fence)
            {
                Delegates.glFinishFenceAPPLE((GLuint)fence);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void FinishFence(GLuint fence)
            {
                Delegates.glFinishFenceAPPLE((GLuint)fence);
            }
            
            public static 
            GLboolean TestObject(GL.Enums.APPLE_fence @object, Int32 name)
            {
                return Delegates.glTestObjectAPPLE((GL.Enums.APPLE_fence)@object, (GLuint)name);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean TestObject(GL.Enums.APPLE_fence @object, GLuint name)
            {
                return Delegates.glTestObjectAPPLE((GL.Enums.APPLE_fence)@object, (GLuint)name);
            }
            
            public static 
            void FinishObject(GL.Enums.APPLE_fence @object, GLint name)
            {
                Delegates.glFinishObjectAPPLE((GL.Enums.APPLE_fence)@object, (GLint)name);
            }
            
            public static 
            void BindVertexArray(Int32 array)
            {
                Delegates.glBindVertexArrayAPPLE((GLuint)array);
            }
            
            [System.CLSCompliant(false)]
            public static 
            void BindVertexArray(GLuint array)
            {
                Delegates.glBindVertexArrayAPPLE((GLuint)array);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteVertexArrays(GLsizei n, Int32* arrays)
            {
                    {
                        Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteVertexArrays(GLsizei n, GLuint* arrays)
            {
                unsafe { Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays); }
            }
            
            public static 
            void DeleteVertexArrays(GLsizei n, Int32[] arrays)
            {
                unsafe
                {
                    fixed (Int32* arrays_ptr = arrays)
                    {
                        Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteVertexArrays(GLsizei n, GLuint[] arrays)
            {
                unsafe
                {
                    fixed (GLuint* arrays_ptr = arrays)
                    {
                        Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
                    }
                }
            }
            
            public static 
            void DeleteVertexArrays(GLsizei n, ref Int32 arrays)
            {
                unsafe
                {
                    fixed (Int32* arrays_ptr = &arrays)
                    {
                        Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void DeleteVertexArrays(GLsizei n, ref GLuint arrays)
            {
                unsafe
                {
                    fixed (GLuint* arrays_ptr = &arrays)
                    {
                        Delegates.glDeleteVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenVertexArrays(GLsizei n, Int32* arrays)
            {
                arrays = default(Int32*);
                    {
                        Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays);
                    }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void GenVertexArrays(GLsizei n, GLuint* arrays)
            {
                unsafe { Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays); }
            }
            
            public static 
            void GenVertexArrays(GLsizei n, Int32[] arrays)
            {
                unsafe
                {
                    fixed (Int32* arrays_ptr = arrays)
                    {
                        Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenVertexArrays(GLsizei n, GLuint[] arrays)
            {
                unsafe
                {
                    fixed (GLuint* arrays_ptr = arrays)
                    {
                        Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
                    }
                }
            }
            
            public static 
            void GenVertexArrays(GLsizei n, out Int32 arrays)
            {
                arrays = default(Int32);
                unsafe
                {
                    fixed (Int32* arrays_ptr = &arrays)
                    {
                        Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
                        arrays = *arrays_ptr;
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            void GenVertexArrays(GLsizei n, out GLuint arrays)
            {
                arrays = default(GLuint);
                unsafe
                {
                    fixed (GLuint* arrays_ptr = &arrays)
                    {
                        Delegates.glGenVertexArraysAPPLE((GLsizei)n, (GLuint*)arrays_ptr);
                        arrays = *arrays_ptr;
                    }
                }
            }
            
            public static 
            GLboolean IsVertexArray(Int32 array)
            {
                return Delegates.glIsVertexArrayAPPLE((GLuint)array);
            }
            
            [System.CLSCompliant(false)]
            public static 
            GLboolean IsVertexArray(GLuint array)
            {
                return Delegates.glIsVertexArrayAPPLE((GLuint)array);
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexArrayRange(GLsizei length, void* pointer)
            {
                unsafe { Delegates.glVertexArrayRangeAPPLE((GLsizei)length, (void*)pointer); }
            }
            
            public static 
            void VertexArrayRange(GLsizei length, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glVertexArrayRangeAPPLE((GLsizei)length, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            [System.CLSCompliant(false)]
            public static 
            unsafe void FlushVertexArrayRange(GLsizei length, void* pointer)
            {
                unsafe { Delegates.glFlushVertexArrayRangeAPPLE((GLsizei)length, (void*)pointer); }
            }
            
            public static 
            void FlushVertexArrayRange(GLsizei length, object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glFlushVertexArrayRangeAPPLE((GLsizei)length, (void*)pointer_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        pointer_ptr.Free();
                    }
                }
            }
            
            public static 
            void VertexArrayParameteri(GL.Enums.APPLE_vertex_array_range pname, GLint param)
            {
                Delegates.glVertexArrayParameteriAPPLE((GL.Enums.APPLE_vertex_array_range)pname, (GLint)param);
            }
            
            public static 
            void BufferParameteri(GL.Enums.APPLE_flush_buffer_range target, GL.Enums.APPLE_flush_buffer_range pname, GLint param)
            {
                Delegates.glBufferParameteriAPPLE((GL.Enums.APPLE_flush_buffer_range)target, (GL.Enums.APPLE_flush_buffer_range)pname, (GLint)param);
            }
            
            public static 
            void FlushMappedBufferRange(GL.Enums.APPLE_flush_buffer_range target, GLintptr offset, GLsizeiptr size)
            {
                Delegates.glFlushMappedBufferRangeAPPLE((GL.Enums.APPLE_flush_buffer_range)target, (GLintptr)offset, (GLsizeiptr)size);
            }
            
        }

        public static class GREMEDY
        {
            [System.CLSCompliant(false)]
            public static 
            unsafe void StringMarker(GLsizei len, void* @string)
            {
                unsafe { Delegates.glStringMarkerGREMEDY((GLsizei)len, (void*)@string); }
            }
            
            public static 
            void StringMarker(GLsizei len, object @string)
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                unsafe
                {
                    try
                    {
                        Delegates.glStringMarkerGREMEDY((GLsizei)len, (void*)@string_ptr.AddrOfPinnedObject());
                    }
                    finally
                    {
                        @string_ptr.Free();
                    }
                }
            }
            
        }

    }
}