wine/dlls/opengl32/thunks.c

/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */

#include <stdarg.h>
#include <stddef.h>

#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"

#include "unixlib.h"
#include "private.h"

#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(opengl);

BOOL WINAPI wglCopyContext( HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask )
{
    struct wglCopyContext_params args = { .teb = NtCurrentTeb(), .hglrcSrc = hglrcSrc, .hglrcDst = hglrcDst, .mask = mask };
    NTSTATUS status;
    TRACE( "hglrcSrc %p, hglrcDst %p, mask %u\n", hglrcSrc, hglrcDst, mask );
    if ((status = UNIX_CALL( wglCopyContext, &args ))) WARN( "wglCopyContext returned %#lx\n", status );
    return args.ret;
}

HGLRC WINAPI wglCreateContext( HDC hDc )
{
    struct wglCreateContext_params args = { .teb = NtCurrentTeb(), .hDc = hDc };
    NTSTATUS status;
    TRACE( "hDc %p\n", hDc );
    if ((status = UNIX_CALL( wglCreateContext, &args ))) WARN( "wglCreateContext returned %#lx\n", status );
    return args.ret;
}

BOOL WINAPI wglDeleteContext( HGLRC oldContext )
{
    struct wglDeleteContext_params args = { .teb = NtCurrentTeb(), .oldContext = oldContext };
    NTSTATUS status;
    TRACE( "oldContext %p\n", oldContext );
    if ((status = UNIX_CALL( wglDeleteContext, &args ))) WARN( "wglDeleteContext returned %#lx\n", status );
    return args.ret;
}

int WINAPI wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR *ppfd )
{
    struct wglDescribePixelFormat_params args = { .teb = NtCurrentTeb(), .hdc = hdc, .ipfd = ipfd, .cjpfd = cjpfd, .ppfd = ppfd };
    NTSTATUS status;
    TRACE( "hdc %p, ipfd %d, cjpfd %u, ppfd %p\n", hdc, ipfd, cjpfd, ppfd );
    if ((status = UNIX_CALL( wglDescribePixelFormat, &args ))) WARN( "wglDescribePixelFormat returned %#lx\n", status );
    return args.ret;
}

BOOL WINAPI wglMakeCurrent( HDC hDc, HGLRC newContext )
{
    struct wglMakeCurrent_params args = { .teb = NtCurrentTeb(), .hDc = hDc, .newContext = newContext };
    NTSTATUS status;
    TRACE( "hDc %p, newContext %p\n", hDc, newContext );
    if ((status = UNIX_CALL( wglMakeCurrent, &args ))) WARN( "wglMakeCurrent returned %#lx\n", status );
    return args.ret;
}

BOOL WINAPI wglSetPixelFormat( HDC hdc, int ipfd, const PIXELFORMATDESCRIPTOR *ppfd )
{
    struct wglSetPixelFormat_params args = { .teb = NtCurrentTeb(), .hdc = hdc, .ipfd = ipfd, .ppfd = ppfd };
    NTSTATUS status;
    TRACE( "hdc %p, ipfd %d, ppfd %p\n", hdc, ipfd, ppfd );
    if ((status = UNIX_CALL( wglSetPixelFormat, &args ))) WARN( "wglSetPixelFormat returned %#lx\n", status );
    return args.ret;
}

BOOL WINAPI wglShareLists( HGLRC hrcSrvShare, HGLRC hrcSrvSource )
{
    struct wglShareLists_params args = { .teb = NtCurrentTeb(), .hrcSrvShare = hrcSrvShare, .hrcSrvSource = hrcSrvSource };
    NTSTATUS status;
    TRACE( "hrcSrvShare %p, hrcSrvSource %p\n", hrcSrvShare, hrcSrvSource );
    if ((status = UNIX_CALL( wglShareLists, &args ))) WARN( "wglShareLists returned %#lx\n", status );
    return args.ret;
}

void WINAPI glAccum( GLenum op, GLfloat value )
{
    struct glAccum_params args = { .teb = NtCurrentTeb(), .op = op, .value = value };
    NTSTATUS status;
    TRACE( "op %d, value %f\n", op, value );
    if ((status = UNIX_CALL( glAccum, &args ))) WARN( "glAccum returned %#lx\n", status );
}

void WINAPI glAlphaFunc( GLenum func, GLfloat ref )
{
    struct glAlphaFunc_params args = { .teb = NtCurrentTeb(), .func = func, .ref = ref };
    NTSTATUS status;
    TRACE( "func %d, ref %f\n", func, ref );
    if ((status = UNIX_CALL( glAlphaFunc, &args ))) WARN( "glAlphaFunc returned %#lx\n", status );
}

GLboolean WINAPI glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )
{
    struct glAreTexturesResident_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures, .residences = residences };
    NTSTATUS status;
    TRACE( "n %d, textures %p, residences %p\n", n, textures, residences );
    if ((status = UNIX_CALL( glAreTexturesResident, &args ))) WARN( "glAreTexturesResident returned %#lx\n", status );
    return args.ret;
}

void WINAPI glArrayElement( GLint i )
{
    struct glArrayElement_params args = { .teb = NtCurrentTeb(), .i = i };
    NTSTATUS status;
    TRACE( "i %d\n", i );
    if ((status = UNIX_CALL( glArrayElement, &args ))) WARN( "glArrayElement returned %#lx\n", status );
}

void WINAPI glBegin( GLenum mode )
{
    struct glBegin_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glBegin, &args ))) WARN( "glBegin returned %#lx\n", status );
}

void WINAPI glBindTexture( GLenum target, GLuint texture )
{
    struct glBindTexture_params args = { .teb = NtCurrentTeb(), .target = target, .texture = texture };
    NTSTATUS status;
    TRACE( "target %d, texture %d\n", target, texture );
    if ((status = UNIX_CALL( glBindTexture, &args ))) WARN( "glBindTexture returned %#lx\n", status );
}

void WINAPI glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
{
    struct glBitmap_params args = { .teb = NtCurrentTeb(), .width = width, .height = height, .xorig = xorig, .yorig = yorig, .xmove = xmove, .ymove = ymove, .bitmap = bitmap };
    NTSTATUS status;
    TRACE( "width %d, height %d, xorig %f, yorig %f, xmove %f, ymove %f, bitmap %p\n", width, height, xorig, yorig, xmove, ymove, bitmap );
    if ((status = UNIX_CALL( glBitmap, &args ))) WARN( "glBitmap returned %#lx\n", status );
}

void WINAPI glBlendFunc( GLenum sfactor, GLenum dfactor )
{
    struct glBlendFunc_params args = { .teb = NtCurrentTeb(), .sfactor = sfactor, .dfactor = dfactor };
    NTSTATUS status;
    TRACE( "sfactor %d, dfactor %d\n", sfactor, dfactor );
    if ((status = UNIX_CALL( glBlendFunc, &args ))) WARN( "glBlendFunc returned %#lx\n", status );
}

void WINAPI glCallList( GLuint list )
{
    struct glCallList_params args = { .teb = NtCurrentTeb(), .list = list };
    NTSTATUS status;
    TRACE( "list %d\n", list );
    if ((status = UNIX_CALL( glCallList, &args ))) WARN( "glCallList returned %#lx\n", status );
}

void WINAPI glCallLists( GLsizei n, GLenum type, const void *lists )
{
    struct glCallLists_params args = { .teb = NtCurrentTeb(), .n = n, .type = type, .lists = lists };
    NTSTATUS status;
    TRACE( "n %d, type %d, lists %p\n", n, type, lists );
    if ((status = UNIX_CALL( glCallLists, &args ))) WARN( "glCallLists returned %#lx\n", status );
}

void WINAPI glClear( GLbitfield mask )
{
    struct glClear_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glClear, &args ))) WARN( "glClear returned %#lx\n", status );
}

void WINAPI glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
    struct glClearAccum_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glClearAccum, &args ))) WARN( "glClearAccum returned %#lx\n", status );
}

void WINAPI glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
    struct glClearColor_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glClearColor, &args ))) WARN( "glClearColor returned %#lx\n", status );
}

void WINAPI glClearDepth( GLdouble depth )
{
    struct glClearDepth_params args = { .teb = NtCurrentTeb(), .depth = depth };
    NTSTATUS status;
    TRACE( "depth %f\n", depth );
    if ((status = UNIX_CALL( glClearDepth, &args ))) WARN( "glClearDepth returned %#lx\n", status );
}

void WINAPI glClearIndex( GLfloat c )
{
    struct glClearIndex_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %f\n", c );
    if ((status = UNIX_CALL( glClearIndex, &args ))) WARN( "glClearIndex returned %#lx\n", status );
}

void WINAPI glClearStencil( GLint s )
{
    struct glClearStencil_params args = { .teb = NtCurrentTeb(), .s = s };
    NTSTATUS status;
    TRACE( "s %d\n", s );
    if ((status = UNIX_CALL( glClearStencil, &args ))) WARN( "glClearStencil returned %#lx\n", status );
}

void WINAPI glClipPlane( GLenum plane, const GLdouble *equation )
{
    struct glClipPlane_params args = { .teb = NtCurrentTeb(), .plane = plane, .equation = equation };
    NTSTATUS status;
    TRACE( "plane %d, equation %p\n", plane, equation );
    if ((status = UNIX_CALL( glClipPlane, &args ))) WARN( "glClipPlane returned %#lx\n", status );
}

void WINAPI glColor3b( GLbyte red, GLbyte green, GLbyte blue )
{
    struct glColor3b_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3b, &args ))) WARN( "glColor3b returned %#lx\n", status );
}

void WINAPI glColor3bv( const GLbyte *v )
{
    struct glColor3bv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3bv, &args ))) WARN( "glColor3bv returned %#lx\n", status );
}

void WINAPI glColor3d( GLdouble red, GLdouble green, GLdouble blue )
{
    struct glColor3d_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3d, &args ))) WARN( "glColor3d returned %#lx\n", status );
}

void WINAPI glColor3dv( const GLdouble *v )
{
    struct glColor3dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3dv, &args ))) WARN( "glColor3dv returned %#lx\n", status );
}

void WINAPI glColor3f( GLfloat red, GLfloat green, GLfloat blue )
{
    struct glColor3f_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3f, &args ))) WARN( "glColor3f returned %#lx\n", status );
}

void WINAPI glColor3fv( const GLfloat *v )
{
    struct glColor3fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3fv, &args ))) WARN( "glColor3fv returned %#lx\n", status );
}

void WINAPI glColor3i( GLint red, GLint green, GLint blue )
{
    struct glColor3i_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3i, &args ))) WARN( "glColor3i returned %#lx\n", status );
}

void WINAPI glColor3iv( const GLint *v )
{
    struct glColor3iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3iv, &args ))) WARN( "glColor3iv returned %#lx\n", status );
}

void WINAPI glColor3s( GLshort red, GLshort green, GLshort blue )
{
    struct glColor3s_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3s, &args ))) WARN( "glColor3s returned %#lx\n", status );
}

void WINAPI glColor3sv( const GLshort *v )
{
    struct glColor3sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3sv, &args ))) WARN( "glColor3sv returned %#lx\n", status );
}

void WINAPI glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
{
    struct glColor3ub_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3ub, &args ))) WARN( "glColor3ub returned %#lx\n", status );
}

void WINAPI glColor3ubv( const GLubyte *v )
{
    struct glColor3ubv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3ubv, &args ))) WARN( "glColor3ubv returned %#lx\n", status );
}

void WINAPI glColor3ui( GLuint red, GLuint green, GLuint blue )
{
    struct glColor3ui_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3ui, &args ))) WARN( "glColor3ui returned %#lx\n", status );
}

void WINAPI glColor3uiv( const GLuint *v )
{
    struct glColor3uiv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3uiv, &args ))) WARN( "glColor3uiv returned %#lx\n", status );
}

void WINAPI glColor3us( GLushort red, GLushort green, GLushort blue )
{
    struct glColor3us_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3us, &args ))) WARN( "glColor3us returned %#lx\n", status );
}

void WINAPI glColor3usv( const GLushort *v )
{
    struct glColor3usv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3usv, &args ))) WARN( "glColor3usv returned %#lx\n", status );
}

void WINAPI glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
{
    struct glColor4b_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4b, &args ))) WARN( "glColor4b returned %#lx\n", status );
}

void WINAPI glColor4bv( const GLbyte *v )
{
    struct glColor4bv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4bv, &args ))) WARN( "glColor4bv returned %#lx\n", status );
}

void WINAPI glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
{
    struct glColor4d_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4d, &args ))) WARN( "glColor4d returned %#lx\n", status );
}

void WINAPI glColor4dv( const GLdouble *v )
{
    struct glColor4dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4dv, &args ))) WARN( "glColor4dv returned %#lx\n", status );
}

void WINAPI glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
    struct glColor4f_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4f, &args ))) WARN( "glColor4f returned %#lx\n", status );
}

void WINAPI glColor4fv( const GLfloat *v )
{
    struct glColor4fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4fv, &args ))) WARN( "glColor4fv returned %#lx\n", status );
}

void WINAPI glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
{
    struct glColor4i_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4i, &args ))) WARN( "glColor4i returned %#lx\n", status );
}

void WINAPI glColor4iv( const GLint *v )
{
    struct glColor4iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4iv, &args ))) WARN( "glColor4iv returned %#lx\n", status );
}

void WINAPI glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
{
    struct glColor4s_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4s, &args ))) WARN( "glColor4s returned %#lx\n", status );
}

void WINAPI glColor4sv( const GLshort *v )
{
    struct glColor4sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4sv, &args ))) WARN( "glColor4sv returned %#lx\n", status );
}

void WINAPI glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
{
    struct glColor4ub_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4ub, &args ))) WARN( "glColor4ub returned %#lx\n", status );
}

void WINAPI glColor4ubv( const GLubyte *v )
{
    struct glColor4ubv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4ubv, &args ))) WARN( "glColor4ubv returned %#lx\n", status );
}

void WINAPI glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
{
    struct glColor4ui_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4ui, &args ))) WARN( "glColor4ui returned %#lx\n", status );
}

void WINAPI glColor4uiv( const GLuint *v )
{
    struct glColor4uiv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4uiv, &args ))) WARN( "glColor4uiv returned %#lx\n", status );
}

void WINAPI glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
{
    struct glColor4us_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4us, &args ))) WARN( "glColor4us returned %#lx\n", status );
}

void WINAPI glColor4usv( const GLushort *v )
{
    struct glColor4usv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4usv, &args ))) WARN( "glColor4usv returned %#lx\n", status );
}

void WINAPI glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
{
    struct glColorMask_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColorMask, &args ))) WARN( "glColorMask returned %#lx\n", status );
}

void WINAPI glColorMaterial( GLenum face, GLenum mode )
{
    struct glColorMaterial_params args = { .teb = NtCurrentTeb(), .face = face, .mode = mode };
    NTSTATUS status;
    TRACE( "face %d, mode %d\n", face, mode );
    if ((status = UNIX_CALL( glColorMaterial, &args ))) WARN( "glColorMaterial returned %#lx\n", status );
}

void WINAPI glColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glColorPointer_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
    if ((status = UNIX_CALL( glColorPointer, &args ))) WARN( "glColorPointer returned %#lx\n", status );
}

void WINAPI glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
{
    struct glCopyPixels_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .width = width, .height = height, .type = type };
    NTSTATUS status;
    TRACE( "x %d, y %d, width %d, height %d, type %d\n", x, y, width, height, type );
    if ((status = UNIX_CALL( glCopyPixels, &args ))) WARN( "glCopyPixels returned %#lx\n", status );
}

void WINAPI glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
{
    struct glCopyTexImage1D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .border = border };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, x %d, y %d, width %d, border %d\n", target, level, internalformat, x, y, width, border );
    if ((status = UNIX_CALL( glCopyTexImage1D, &args ))) WARN( "glCopyTexImage1D returned %#lx\n", status );
}

void WINAPI glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
{
    struct glCopyTexImage2D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .height = height, .border = border };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, x %d, y %d, width %d, height %d, border %d\n", target, level, internalformat, x, y, width, height, border );
    if ((status = UNIX_CALL( glCopyTexImage2D, &args ))) WARN( "glCopyTexImage2D returned %#lx\n", status );
}

void WINAPI glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
{
    struct glCopyTexSubImage1D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, x %d, y %d, width %d\n", target, level, xoffset, x, y, width );
    if ((status = UNIX_CALL( glCopyTexSubImage1D, &args ))) WARN( "glCopyTexSubImage1D returned %#lx\n", status );
}

void WINAPI glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyTexSubImage2D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, x %d, y %d, width %d, height %d\n", target, level, xoffset, yoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyTexSubImage2D, &args ))) WARN( "glCopyTexSubImage2D returned %#lx\n", status );
}

void WINAPI glCullFace( GLenum mode )
{
    struct glCullFace_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glCullFace, &args ))) WARN( "glCullFace returned %#lx\n", status );
}

void WINAPI glDeleteLists( GLuint list, GLsizei range )
{
    struct glDeleteLists_params args = { .teb = NtCurrentTeb(), .list = list, .range = range };
    NTSTATUS status;
    TRACE( "list %d, range %d\n", list, range );
    if ((status = UNIX_CALL( glDeleteLists, &args ))) WARN( "glDeleteLists returned %#lx\n", status );
}

void WINAPI glDeleteTextures( GLsizei n, const GLuint *textures )
{
    struct glDeleteTextures_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures };
    NTSTATUS status;
    TRACE( "n %d, textures %p\n", n, textures );
    if ((status = UNIX_CALL( glDeleteTextures, &args ))) WARN( "glDeleteTextures returned %#lx\n", status );
}

void WINAPI glDepthFunc( GLenum func )
{
    struct glDepthFunc_params args = { .teb = NtCurrentTeb(), .func = func };
    NTSTATUS status;
    TRACE( "func %d\n", func );
    if ((status = UNIX_CALL( glDepthFunc, &args ))) WARN( "glDepthFunc returned %#lx\n", status );
}

void WINAPI glDepthMask( GLboolean flag )
{
    struct glDepthMask_params args = { .teb = NtCurrentTeb(), .flag = flag };
    NTSTATUS status;
    TRACE( "flag %d\n", flag );
    if ((status = UNIX_CALL( glDepthMask, &args ))) WARN( "glDepthMask returned %#lx\n", status );
}

void WINAPI glDepthRange( GLdouble n, GLdouble f )
{
    struct glDepthRange_params args = { .teb = NtCurrentTeb(), .n = n, .f = f };
    NTSTATUS status;
    TRACE( "n %f, f %f\n", n, f );
    if ((status = UNIX_CALL( glDepthRange, &args ))) WARN( "glDepthRange returned %#lx\n", status );
}

void WINAPI glDisable( GLenum cap )
{
    struct glDisable_params args = { .teb = NtCurrentTeb(), .cap = cap };
    NTSTATUS status;
    TRACE( "cap %d\n", cap );
    if ((status = UNIX_CALL( glDisable, &args ))) WARN( "glDisable returned %#lx\n", status );
}

void WINAPI glDisableClientState( GLenum array )
{
    struct glDisableClientState_params args = { .teb = NtCurrentTeb(), .array = array };
    NTSTATUS status;
    TRACE( "array %d\n", array );
    if ((status = UNIX_CALL( glDisableClientState, &args ))) WARN( "glDisableClientState returned %#lx\n", status );
}

void WINAPI glDrawArrays( GLenum mode, GLint first, GLsizei count )
{
    struct glDrawArrays_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count };
    NTSTATUS status;
    TRACE( "mode %d, first %d, count %d\n", mode, first, count );
    if ((status = UNIX_CALL( glDrawArrays, &args ))) WARN( "glDrawArrays returned %#lx\n", status );
}

void WINAPI glDrawBuffer( GLenum buf )
{
    struct glDrawBuffer_params args = { .teb = NtCurrentTeb(), .buf = buf };
    NTSTATUS status;
    TRACE( "buf %d\n", buf );
    if ((status = UNIX_CALL( glDrawBuffer, &args ))) WARN( "glDrawBuffer returned %#lx\n", status );
}

void WINAPI glDrawElements( GLenum mode, GLsizei count, GLenum type, const void *indices )
{
    struct glDrawElements_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices };
    NTSTATUS status;
    TRACE( "mode %d, count %d, type %d, indices %p\n", mode, count, type, indices );
    if ((status = UNIX_CALL( glDrawElements, &args ))) WARN( "glDrawElements returned %#lx\n", status );
}

void WINAPI glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
{
    struct glDrawPixels_params args = { .teb = NtCurrentTeb(), .width = width, .height = height, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "width %d, height %d, format %d, type %d, pixels %p\n", width, height, format, type, pixels );
    if ((status = UNIX_CALL( glDrawPixels, &args ))) WARN( "glDrawPixels returned %#lx\n", status );
}

void WINAPI glEdgeFlag( GLboolean flag )
{
    struct glEdgeFlag_params args = { .teb = NtCurrentTeb(), .flag = flag };
    NTSTATUS status;
    TRACE( "flag %d\n", flag );
    if ((status = UNIX_CALL( glEdgeFlag, &args ))) WARN( "glEdgeFlag returned %#lx\n", status );
}

void WINAPI glEdgeFlagPointer( GLsizei stride, const void *pointer )
{
    struct glEdgeFlagPointer_params args = { .teb = NtCurrentTeb(), .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "stride %d, pointer %p\n", stride, pointer );
    if ((status = UNIX_CALL( glEdgeFlagPointer, &args ))) WARN( "glEdgeFlagPointer returned %#lx\n", status );
}

void WINAPI glEdgeFlagv( const GLboolean *flag )
{
    struct glEdgeFlagv_params args = { .teb = NtCurrentTeb(), .flag = flag };
    NTSTATUS status;
    TRACE( "flag %p\n", flag );
    if ((status = UNIX_CALL( glEdgeFlagv, &args ))) WARN( "glEdgeFlagv returned %#lx\n", status );
}

void WINAPI glEnable( GLenum cap )
{
    struct glEnable_params args = { .teb = NtCurrentTeb(), .cap = cap };
    NTSTATUS status;
    TRACE( "cap %d\n", cap );
    if ((status = UNIX_CALL( glEnable, &args ))) WARN( "glEnable returned %#lx\n", status );
}

void WINAPI glEnableClientState( GLenum array )
{
    struct glEnableClientState_params args = { .teb = NtCurrentTeb(), .array = array };
    NTSTATUS status;
    TRACE( "array %d\n", array );
    if ((status = UNIX_CALL( glEnableClientState, &args ))) WARN( "glEnableClientState returned %#lx\n", status );
}

void WINAPI glEnd(void)
{
    struct glEnd_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEnd, &args ))) WARN( "glEnd returned %#lx\n", status );
}

void WINAPI glEndList(void)
{
    struct glEndList_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndList, &args ))) WARN( "glEndList returned %#lx\n", status );
}

void WINAPI glEvalCoord1d( GLdouble u )
{
    struct glEvalCoord1d_params args = { .teb = NtCurrentTeb(), .u = u };
    NTSTATUS status;
    TRACE( "u %f\n", u );
    if ((status = UNIX_CALL( glEvalCoord1d, &args ))) WARN( "glEvalCoord1d returned %#lx\n", status );
}

void WINAPI glEvalCoord1dv( const GLdouble *u )
{
    struct glEvalCoord1dv_params args = { .teb = NtCurrentTeb(), .u = u };
    NTSTATUS status;
    TRACE( "u %p\n", u );
    if ((status = UNIX_CALL( glEvalCoord1dv, &args ))) WARN( "glEvalCoord1dv returned %#lx\n", status );
}

void WINAPI glEvalCoord1f( GLfloat u )
{
    struct glEvalCoord1f_params args = { .teb = NtCurrentTeb(), .u = u };
    NTSTATUS status;
    TRACE( "u %f\n", u );
    if ((status = UNIX_CALL( glEvalCoord1f, &args ))) WARN( "glEvalCoord1f returned %#lx\n", status );
}

void WINAPI glEvalCoord1fv( const GLfloat *u )
{
    struct glEvalCoord1fv_params args = { .teb = NtCurrentTeb(), .u = u };
    NTSTATUS status;
    TRACE( "u %p\n", u );
    if ((status = UNIX_CALL( glEvalCoord1fv, &args ))) WARN( "glEvalCoord1fv returned %#lx\n", status );
}

void WINAPI glEvalCoord2d( GLdouble u, GLdouble v )
{
    struct glEvalCoord2d_params args = { .teb = NtCurrentTeb(), .u = u, .v = v };
    NTSTATUS status;
    TRACE( "u %f, v %f\n", u, v );
    if ((status = UNIX_CALL( glEvalCoord2d, &args ))) WARN( "glEvalCoord2d returned %#lx\n", status );
}

void WINAPI glEvalCoord2dv( const GLdouble *u )
{
    struct glEvalCoord2dv_params args = { .teb = NtCurrentTeb(), .u = u };
    NTSTATUS status;
    TRACE( "u %p\n", u );
    if ((status = UNIX_CALL( glEvalCoord2dv, &args ))) WARN( "glEvalCoord2dv returned %#lx\n", status );
}

void WINAPI glEvalCoord2f( GLfloat u, GLfloat v )
{
    struct glEvalCoord2f_params args = { .teb = NtCurrentTeb(), .u = u, .v = v };
    NTSTATUS status;
    TRACE( "u %f, v %f\n", u, v );
    if ((status = UNIX_CALL( glEvalCoord2f, &args ))) WARN( "glEvalCoord2f returned %#lx\n", status );
}

void WINAPI glEvalCoord2fv( const GLfloat *u )
{
    struct glEvalCoord2fv_params args = { .teb = NtCurrentTeb(), .u = u };
    NTSTATUS status;
    TRACE( "u %p\n", u );
    if ((status = UNIX_CALL( glEvalCoord2fv, &args ))) WARN( "glEvalCoord2fv returned %#lx\n", status );
}

void WINAPI glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
{
    struct glEvalMesh1_params args = { .teb = NtCurrentTeb(), .mode = mode, .i1 = i1, .i2 = i2 };
    NTSTATUS status;
    TRACE( "mode %d, i1 %d, i2 %d\n", mode, i1, i2 );
    if ((status = UNIX_CALL( glEvalMesh1, &args ))) WARN( "glEvalMesh1 returned %#lx\n", status );
}

void WINAPI glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
{
    struct glEvalMesh2_params args = { .teb = NtCurrentTeb(), .mode = mode, .i1 = i1, .i2 = i2, .j1 = j1, .j2 = j2 };
    NTSTATUS status;
    TRACE( "mode %d, i1 %d, i2 %d, j1 %d, j2 %d\n", mode, i1, i2, j1, j2 );
    if ((status = UNIX_CALL( glEvalMesh2, &args ))) WARN( "glEvalMesh2 returned %#lx\n", status );
}

void WINAPI glEvalPoint1( GLint i )
{
    struct glEvalPoint1_params args = { .teb = NtCurrentTeb(), .i = i };
    NTSTATUS status;
    TRACE( "i %d\n", i );
    if ((status = UNIX_CALL( glEvalPoint1, &args ))) WARN( "glEvalPoint1 returned %#lx\n", status );
}

void WINAPI glEvalPoint2( GLint i, GLint j )
{
    struct glEvalPoint2_params args = { .teb = NtCurrentTeb(), .i = i, .j = j };
    NTSTATUS status;
    TRACE( "i %d, j %d\n", i, j );
    if ((status = UNIX_CALL( glEvalPoint2, &args ))) WARN( "glEvalPoint2 returned %#lx\n", status );
}

void WINAPI glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
{
    struct glFeedbackBuffer_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .buffer = buffer };
    NTSTATUS status;
    TRACE( "size %d, type %d, buffer %p\n", size, type, buffer );
    if ((status = UNIX_CALL( glFeedbackBuffer, &args ))) WARN( "glFeedbackBuffer returned %#lx\n", status );
}

void WINAPI glFinish(void)
{
    struct glFinish_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glFinish, &args ))) WARN( "glFinish returned %#lx\n", status );
}

void WINAPI glFlush(void)
{
    struct glFlush_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glFlush, &args ))) WARN( "glFlush returned %#lx\n", status );
}

void WINAPI glFogf( GLenum pname, GLfloat param )
{
    struct glFogf_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glFogf, &args ))) WARN( "glFogf returned %#lx\n", status );
}

void WINAPI glFogfv( GLenum pname, const GLfloat *params )
{
    struct glFogfv_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glFogfv, &args ))) WARN( "glFogfv returned %#lx\n", status );
}

void WINAPI glFogi( GLenum pname, GLint param )
{
    struct glFogi_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glFogi, &args ))) WARN( "glFogi returned %#lx\n", status );
}

void WINAPI glFogiv( GLenum pname, const GLint *params )
{
    struct glFogiv_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glFogiv, &args ))) WARN( "glFogiv returned %#lx\n", status );
}

void WINAPI glFrontFace( GLenum mode )
{
    struct glFrontFace_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glFrontFace, &args ))) WARN( "glFrontFace returned %#lx\n", status );
}

void WINAPI glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
{
    struct glFrustum_params args = { .teb = NtCurrentTeb(), .left = left, .right = right, .bottom = bottom, .top = top, .zNear = zNear, .zFar = zFar };
    NTSTATUS status;
    TRACE( "left %f, right %f, bottom %f, top %f, zNear %f, zFar %f\n", left, right, bottom, top, zNear, zFar );
    if ((status = UNIX_CALL( glFrustum, &args ))) WARN( "glFrustum returned %#lx\n", status );
}

GLuint WINAPI glGenLists( GLsizei range )
{
    struct glGenLists_params args = { .teb = NtCurrentTeb(), .range = range };
    NTSTATUS status;
    TRACE( "range %d\n", range );
    if ((status = UNIX_CALL( glGenLists, &args ))) WARN( "glGenLists returned %#lx\n", status );
    return args.ret;
}

void WINAPI glGenTextures( GLsizei n, GLuint *textures )
{
    struct glGenTextures_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures };
    NTSTATUS status;
    TRACE( "n %d, textures %p\n", n, textures );
    if ((status = UNIX_CALL( glGenTextures, &args ))) WARN( "glGenTextures returned %#lx\n", status );
}

void WINAPI glGetBooleanv( GLenum pname, GLboolean *data )
{
    struct glGetBooleanv_params args = { .teb = NtCurrentTeb(), .pname = pname, .data = data };
    NTSTATUS status;
    TRACE( "pname %d, data %p\n", pname, data );
    if ((status = UNIX_CALL( glGetBooleanv, &args ))) WARN( "glGetBooleanv returned %#lx\n", status );
}

void WINAPI glGetClipPlane( GLenum plane, GLdouble *equation )
{
    struct glGetClipPlane_params args = { .teb = NtCurrentTeb(), .plane = plane, .equation = equation };
    NTSTATUS status;
    TRACE( "plane %d, equation %p\n", plane, equation );
    if ((status = UNIX_CALL( glGetClipPlane, &args ))) WARN( "glGetClipPlane returned %#lx\n", status );
}

void WINAPI glGetDoublev( GLenum pname, GLdouble *data )
{
    struct glGetDoublev_params args = { .teb = NtCurrentTeb(), .pname = pname, .data = data };
    NTSTATUS status;
    TRACE( "pname %d, data %p\n", pname, data );
    if ((status = UNIX_CALL( glGetDoublev, &args ))) WARN( "glGetDoublev returned %#lx\n", status );
}

GLenum WINAPI glGetError(void)
{
    struct glGetError_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glGetError, &args ))) WARN( "glGetError returned %#lx\n", status );
    return args.ret;
}

void WINAPI glGetFloatv( GLenum pname, GLfloat *data )
{
    struct glGetFloatv_params args = { .teb = NtCurrentTeb(), .pname = pname, .data = data };
    NTSTATUS status;
    TRACE( "pname %d, data %p\n", pname, data );
    if ((status = UNIX_CALL( glGetFloatv, &args ))) WARN( "glGetFloatv returned %#lx\n", status );
}

void WINAPI glGetIntegerv( GLenum pname, GLint *data )
{
    struct glGetIntegerv_params args = { .teb = NtCurrentTeb(), .pname = pname, .data = data };
    NTSTATUS status;
    TRACE( "pname %d, data %p\n", pname, data );
    if ((status = UNIX_CALL( glGetIntegerv, &args ))) WARN( "glGetIntegerv returned %#lx\n", status );
}

void WINAPI glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
{
    struct glGetLightfv_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glGetLightfv, &args ))) WARN( "glGetLightfv returned %#lx\n", status );
}

void WINAPI glGetLightiv( GLenum light, GLenum pname, GLint *params )
{
    struct glGetLightiv_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glGetLightiv, &args ))) WARN( "glGetLightiv returned %#lx\n", status );
}

void WINAPI glGetMapdv( GLenum target, GLenum query, GLdouble *v )
{
    struct glGetMapdv_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, v %p\n", target, query, v );
    if ((status = UNIX_CALL( glGetMapdv, &args ))) WARN( "glGetMapdv returned %#lx\n", status );
}

void WINAPI glGetMapfv( GLenum target, GLenum query, GLfloat *v )
{
    struct glGetMapfv_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, v %p\n", target, query, v );
    if ((status = UNIX_CALL( glGetMapfv, &args ))) WARN( "glGetMapfv returned %#lx\n", status );
}

void WINAPI glGetMapiv( GLenum target, GLenum query, GLint *v )
{
    struct glGetMapiv_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, v %p\n", target, query, v );
    if ((status = UNIX_CALL( glGetMapiv, &args ))) WARN( "glGetMapiv returned %#lx\n", status );
}

void WINAPI glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
{
    struct glGetMaterialfv_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
    if ((status = UNIX_CALL( glGetMaterialfv, &args ))) WARN( "glGetMaterialfv returned %#lx\n", status );
}

void WINAPI glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
{
    struct glGetMaterialiv_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
    if ((status = UNIX_CALL( glGetMaterialiv, &args ))) WARN( "glGetMaterialiv returned %#lx\n", status );
}

void WINAPI glGetPixelMapfv( GLenum map, GLfloat *values )
{
    struct glGetPixelMapfv_params args = { .teb = NtCurrentTeb(), .map = map, .values = values };
    NTSTATUS status;
    TRACE( "map %d, values %p\n", map, values );
    if ((status = UNIX_CALL( glGetPixelMapfv, &args ))) WARN( "glGetPixelMapfv returned %#lx\n", status );
}

void WINAPI glGetPixelMapuiv( GLenum map, GLuint *values )
{
    struct glGetPixelMapuiv_params args = { .teb = NtCurrentTeb(), .map = map, .values = values };
    NTSTATUS status;
    TRACE( "map %d, values %p\n", map, values );
    if ((status = UNIX_CALL( glGetPixelMapuiv, &args ))) WARN( "glGetPixelMapuiv returned %#lx\n", status );
}

void WINAPI glGetPixelMapusv( GLenum map, GLushort *values )
{
    struct glGetPixelMapusv_params args = { .teb = NtCurrentTeb(), .map = map, .values = values };
    NTSTATUS status;
    TRACE( "map %d, values %p\n", map, values );
    if ((status = UNIX_CALL( glGetPixelMapusv, &args ))) WARN( "glGetPixelMapusv returned %#lx\n", status );
}

void WINAPI glGetPointerv( GLenum pname, void **params )
{
    struct glGetPointerv_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glGetPointerv, &args ))) WARN( "glGetPointerv returned %#lx\n", status );
}

void WINAPI glGetPolygonStipple( GLubyte *mask )
{
    struct glGetPolygonStipple_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %p\n", mask );
    if ((status = UNIX_CALL( glGetPolygonStipple, &args ))) WARN( "glGetPolygonStipple returned %#lx\n", status );
}

void WINAPI glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetTexEnvfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexEnvfv, &args ))) WARN( "glGetTexEnvfv returned %#lx\n", status );
}

void WINAPI glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetTexEnviv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexEnviv, &args ))) WARN( "glGetTexEnviv returned %#lx\n", status );
}

void WINAPI glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
{
    struct glGetTexGendv_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
    if ((status = UNIX_CALL( glGetTexGendv, &args ))) WARN( "glGetTexGendv returned %#lx\n", status );
}

void WINAPI glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
{
    struct glGetTexGenfv_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
    if ((status = UNIX_CALL( glGetTexGenfv, &args ))) WARN( "glGetTexGenfv returned %#lx\n", status );
}

void WINAPI glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
{
    struct glGetTexGeniv_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
    if ((status = UNIX_CALL( glGetTexGeniv, &args ))) WARN( "glGetTexGeniv returned %#lx\n", status );
}

void WINAPI glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
{
    struct glGetTexImage_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, format %d, type %d, pixels %p\n", target, level, format, type, pixels );
    if ((status = UNIX_CALL( glGetTexImage, &args ))) WARN( "glGetTexImage returned %#lx\n", status );
}

void WINAPI glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )
{
    struct glGetTexLevelParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, level %d, pname %d, params %p\n", target, level, pname, params );
    if ((status = UNIX_CALL( glGetTexLevelParameterfv, &args ))) WARN( "glGetTexLevelParameterfv returned %#lx\n", status );
}

void WINAPI glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )
{
    struct glGetTexLevelParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, level %d, pname %d, params %p\n", target, level, pname, params );
    if ((status = UNIX_CALL( glGetTexLevelParameteriv, &args ))) WARN( "glGetTexLevelParameteriv returned %#lx\n", status );
}

void WINAPI glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetTexParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexParameterfv, &args ))) WARN( "glGetTexParameterfv returned %#lx\n", status );
}

void WINAPI glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetTexParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexParameteriv, &args ))) WARN( "glGetTexParameteriv returned %#lx\n", status );
}

void WINAPI glHint( GLenum target, GLenum mode )
{
    struct glHint_params args = { .teb = NtCurrentTeb(), .target = target, .mode = mode };
    NTSTATUS status;
    TRACE( "target %d, mode %d\n", target, mode );
    if ((status = UNIX_CALL( glHint, &args ))) WARN( "glHint returned %#lx\n", status );
}

void WINAPI glIndexMask( GLuint mask )
{
    struct glIndexMask_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glIndexMask, &args ))) WARN( "glIndexMask returned %#lx\n", status );
}

void WINAPI glIndexPointer( GLenum type, GLsizei stride, const void *pointer )
{
    struct glIndexPointer_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
    if ((status = UNIX_CALL( glIndexPointer, &args ))) WARN( "glIndexPointer returned %#lx\n", status );
}

void WINAPI glIndexd( GLdouble c )
{
    struct glIndexd_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %f\n", c );
    if ((status = UNIX_CALL( glIndexd, &args ))) WARN( "glIndexd returned %#lx\n", status );
}

void WINAPI glIndexdv( const GLdouble *c )
{
    struct glIndexdv_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %p\n", c );
    if ((status = UNIX_CALL( glIndexdv, &args ))) WARN( "glIndexdv returned %#lx\n", status );
}

void WINAPI glIndexf( GLfloat c )
{
    struct glIndexf_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %f\n", c );
    if ((status = UNIX_CALL( glIndexf, &args ))) WARN( "glIndexf returned %#lx\n", status );
}

void WINAPI glIndexfv( const GLfloat *c )
{
    struct glIndexfv_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %p\n", c );
    if ((status = UNIX_CALL( glIndexfv, &args ))) WARN( "glIndexfv returned %#lx\n", status );
}

void WINAPI glIndexi( GLint c )
{
    struct glIndexi_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %d\n", c );
    if ((status = UNIX_CALL( glIndexi, &args ))) WARN( "glIndexi returned %#lx\n", status );
}

void WINAPI glIndexiv( const GLint *c )
{
    struct glIndexiv_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %p\n", c );
    if ((status = UNIX_CALL( glIndexiv, &args ))) WARN( "glIndexiv returned %#lx\n", status );
}

void WINAPI glIndexs( GLshort c )
{
    struct glIndexs_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %d\n", c );
    if ((status = UNIX_CALL( glIndexs, &args ))) WARN( "glIndexs returned %#lx\n", status );
}

void WINAPI glIndexsv( const GLshort *c )
{
    struct glIndexsv_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %p\n", c );
    if ((status = UNIX_CALL( glIndexsv, &args ))) WARN( "glIndexsv returned %#lx\n", status );
}

void WINAPI glIndexub( GLubyte c )
{
    struct glIndexub_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %d\n", c );
    if ((status = UNIX_CALL( glIndexub, &args ))) WARN( "glIndexub returned %#lx\n", status );
}

void WINAPI glIndexubv( const GLubyte *c )
{
    struct glIndexubv_params args = { .teb = NtCurrentTeb(), .c = c };
    NTSTATUS status;
    TRACE( "c %p\n", c );
    if ((status = UNIX_CALL( glIndexubv, &args ))) WARN( "glIndexubv returned %#lx\n", status );
}

void WINAPI glInitNames(void)
{
    struct glInitNames_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glInitNames, &args ))) WARN( "glInitNames returned %#lx\n", status );
}

void WINAPI glInterleavedArrays( GLenum format, GLsizei stride, const void *pointer )
{
    struct glInterleavedArrays_params args = { .teb = NtCurrentTeb(), .format = format, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "format %d, stride %d, pointer %p\n", format, stride, pointer );
    if ((status = UNIX_CALL( glInterleavedArrays, &args ))) WARN( "glInterleavedArrays returned %#lx\n", status );
}

GLboolean WINAPI glIsEnabled( GLenum cap )
{
    struct glIsEnabled_params args = { .teb = NtCurrentTeb(), .cap = cap };
    NTSTATUS status;
    TRACE( "cap %d\n", cap );
    if ((status = UNIX_CALL( glIsEnabled, &args ))) WARN( "glIsEnabled returned %#lx\n", status );
    return args.ret;
}

GLboolean WINAPI glIsList( GLuint list )
{
    struct glIsList_params args = { .teb = NtCurrentTeb(), .list = list };
    NTSTATUS status;
    TRACE( "list %d\n", list );
    if ((status = UNIX_CALL( glIsList, &args ))) WARN( "glIsList returned %#lx\n", status );
    return args.ret;
}

GLboolean WINAPI glIsTexture( GLuint texture )
{
    struct glIsTexture_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glIsTexture, &args ))) WARN( "glIsTexture returned %#lx\n", status );
    return args.ret;
}

void WINAPI glLightModelf( GLenum pname, GLfloat param )
{
    struct glLightModelf_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glLightModelf, &args ))) WARN( "glLightModelf returned %#lx\n", status );
}

void WINAPI glLightModelfv( GLenum pname, const GLfloat *params )
{
    struct glLightModelfv_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glLightModelfv, &args ))) WARN( "glLightModelfv returned %#lx\n", status );
}

void WINAPI glLightModeli( GLenum pname, GLint param )
{
    struct glLightModeli_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glLightModeli, &args ))) WARN( "glLightModeli returned %#lx\n", status );
}

void WINAPI glLightModeliv( GLenum pname, const GLint *params )
{
    struct glLightModeliv_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glLightModeliv, &args ))) WARN( "glLightModeliv returned %#lx\n", status );
}

void WINAPI glLightf( GLenum light, GLenum pname, GLfloat param )
{
    struct glLightf_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "light %d, pname %d, param %f\n", light, pname, param );
    if ((status = UNIX_CALL( glLightf, &args ))) WARN( "glLightf returned %#lx\n", status );
}

void WINAPI glLightfv( GLenum light, GLenum pname, const GLfloat *params )
{
    struct glLightfv_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glLightfv, &args ))) WARN( "glLightfv returned %#lx\n", status );
}

void WINAPI glLighti( GLenum light, GLenum pname, GLint param )
{
    struct glLighti_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "light %d, pname %d, param %d\n", light, pname, param );
    if ((status = UNIX_CALL( glLighti, &args ))) WARN( "glLighti returned %#lx\n", status );
}

void WINAPI glLightiv( GLenum light, GLenum pname, const GLint *params )
{
    struct glLightiv_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glLightiv, &args ))) WARN( "glLightiv returned %#lx\n", status );
}

void WINAPI glLineStipple( GLint factor, GLushort pattern )
{
    struct glLineStipple_params args = { .teb = NtCurrentTeb(), .factor = factor, .pattern = pattern };
    NTSTATUS status;
    TRACE( "factor %d, pattern %d\n", factor, pattern );
    if ((status = UNIX_CALL( glLineStipple, &args ))) WARN( "glLineStipple returned %#lx\n", status );
}

void WINAPI glLineWidth( GLfloat width )
{
    struct glLineWidth_params args = { .teb = NtCurrentTeb(), .width = width };
    NTSTATUS status;
    TRACE( "width %f\n", width );
    if ((status = UNIX_CALL( glLineWidth, &args ))) WARN( "glLineWidth returned %#lx\n", status );
}

void WINAPI glListBase( GLuint base )
{
    struct glListBase_params args = { .teb = NtCurrentTeb(), .base = base };
    NTSTATUS status;
    TRACE( "base %d\n", base );
    if ((status = UNIX_CALL( glListBase, &args ))) WARN( "glListBase returned %#lx\n", status );
}

void WINAPI glLoadIdentity(void)
{
    struct glLoadIdentity_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glLoadIdentity, &args ))) WARN( "glLoadIdentity returned %#lx\n", status );
}

void WINAPI glLoadMatrixd( const GLdouble *m )
{
    struct glLoadMatrixd_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glLoadMatrixd, &args ))) WARN( "glLoadMatrixd returned %#lx\n", status );
}

void WINAPI glLoadMatrixf( const GLfloat *m )
{
    struct glLoadMatrixf_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glLoadMatrixf, &args ))) WARN( "glLoadMatrixf returned %#lx\n", status );
}

void WINAPI glLoadName( GLuint name )
{
    struct glLoadName_params args = { .teb = NtCurrentTeb(), .name = name };
    NTSTATUS status;
    TRACE( "name %d\n", name );
    if ((status = UNIX_CALL( glLoadName, &args ))) WARN( "glLoadName returned %#lx\n", status );
}

void WINAPI glLogicOp( GLenum opcode )
{
    struct glLogicOp_params args = { .teb = NtCurrentTeb(), .opcode = opcode };
    NTSTATUS status;
    TRACE( "opcode %d\n", opcode );
    if ((status = UNIX_CALL( glLogicOp, &args ))) WARN( "glLogicOp returned %#lx\n", status );
}

void WINAPI glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
{
    struct glMap1d_params args = { .teb = NtCurrentTeb(), .target = target, .u1 = u1, .u2 = u2, .stride = stride, .order = order, .points = points };
    NTSTATUS status;
    TRACE( "target %d, u1 %f, u2 %f, stride %d, order %d, points %p\n", target, u1, u2, stride, order, points );
    if ((status = UNIX_CALL( glMap1d, &args ))) WARN( "glMap1d returned %#lx\n", status );
}

void WINAPI glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
{
    struct glMap1f_params args = { .teb = NtCurrentTeb(), .target = target, .u1 = u1, .u2 = u2, .stride = stride, .order = order, .points = points };
    NTSTATUS status;
    TRACE( "target %d, u1 %f, u2 %f, stride %d, order %d, points %p\n", target, u1, u2, stride, order, points );
    if ((status = UNIX_CALL( glMap1f, &args ))) WARN( "glMap1f returned %#lx\n", status );
}

void WINAPI glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
{
    struct glMap2d_params args = { .teb = NtCurrentTeb(), .target = target, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .points = points };
    NTSTATUS status;
    TRACE( "target %d, u1 %f, u2 %f, ustride %d, uorder %d, v1 %f, v2 %f, vstride %d, vorder %d, points %p\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
    if ((status = UNIX_CALL( glMap2d, &args ))) WARN( "glMap2d returned %#lx\n", status );
}

void WINAPI glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
{
    struct glMap2f_params args = { .teb = NtCurrentTeb(), .target = target, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .points = points };
    NTSTATUS status;
    TRACE( "target %d, u1 %f, u2 %f, ustride %d, uorder %d, v1 %f, v2 %f, vstride %d, vorder %d, points %p\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
    if ((status = UNIX_CALL( glMap2f, &args ))) WARN( "glMap2f returned %#lx\n", status );
}

void WINAPI glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
{
    struct glMapGrid1d_params args = { .teb = NtCurrentTeb(), .un = un, .u1 = u1, .u2 = u2 };
    NTSTATUS status;
    TRACE( "un %d, u1 %f, u2 %f\n", un, u1, u2 );
    if ((status = UNIX_CALL( glMapGrid1d, &args ))) WARN( "glMapGrid1d returned %#lx\n", status );
}

void WINAPI glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
{
    struct glMapGrid1f_params args = { .teb = NtCurrentTeb(), .un = un, .u1 = u1, .u2 = u2 };
    NTSTATUS status;
    TRACE( "un %d, u1 %f, u2 %f\n", un, u1, u2 );
    if ((status = UNIX_CALL( glMapGrid1f, &args ))) WARN( "glMapGrid1f returned %#lx\n", status );
}

void WINAPI glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
{
    struct glMapGrid2d_params args = { .teb = NtCurrentTeb(), .un = un, .u1 = u1, .u2 = u2, .vn = vn, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "un %d, u1 %f, u2 %f, vn %d, v1 %f, v2 %f\n", un, u1, u2, vn, v1, v2 );
    if ((status = UNIX_CALL( glMapGrid2d, &args ))) WARN( "glMapGrid2d returned %#lx\n", status );
}

void WINAPI glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
{
    struct glMapGrid2f_params args = { .teb = NtCurrentTeb(), .un = un, .u1 = u1, .u2 = u2, .vn = vn, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "un %d, u1 %f, u2 %f, vn %d, v1 %f, v2 %f\n", un, u1, u2, vn, v1, v2 );
    if ((status = UNIX_CALL( glMapGrid2f, &args ))) WARN( "glMapGrid2f returned %#lx\n", status );
}

void WINAPI glMaterialf( GLenum face, GLenum pname, GLfloat param )
{
    struct glMaterialf_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "face %d, pname %d, param %f\n", face, pname, param );
    if ((status = UNIX_CALL( glMaterialf, &args ))) WARN( "glMaterialf returned %#lx\n", status );
}

void WINAPI glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
{
    struct glMaterialfv_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
    if ((status = UNIX_CALL( glMaterialfv, &args ))) WARN( "glMaterialfv returned %#lx\n", status );
}

void WINAPI glMateriali( GLenum face, GLenum pname, GLint param )
{
    struct glMateriali_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "face %d, pname %d, param %d\n", face, pname, param );
    if ((status = UNIX_CALL( glMateriali, &args ))) WARN( "glMateriali returned %#lx\n", status );
}

void WINAPI glMaterialiv( GLenum face, GLenum pname, const GLint *params )
{
    struct glMaterialiv_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
    if ((status = UNIX_CALL( glMaterialiv, &args ))) WARN( "glMaterialiv returned %#lx\n", status );
}

void WINAPI glMatrixMode( GLenum mode )
{
    struct glMatrixMode_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glMatrixMode, &args ))) WARN( "glMatrixMode returned %#lx\n", status );
}

void WINAPI glMultMatrixd( const GLdouble *m )
{
    struct glMultMatrixd_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glMultMatrixd, &args ))) WARN( "glMultMatrixd returned %#lx\n", status );
}

void WINAPI glMultMatrixf( const GLfloat *m )
{
    struct glMultMatrixf_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glMultMatrixf, &args ))) WARN( "glMultMatrixf returned %#lx\n", status );
}

void WINAPI glNewList( GLuint list, GLenum mode )
{
    struct glNewList_params args = { .teb = NtCurrentTeb(), .list = list, .mode = mode };
    NTSTATUS status;
    TRACE( "list %d, mode %d\n", list, mode );
    if ((status = UNIX_CALL( glNewList, &args ))) WARN( "glNewList returned %#lx\n", status );
}

void WINAPI glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
{
    struct glNormal3b_params args = { .teb = NtCurrentTeb(), .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "nx %d, ny %d, nz %d\n", nx, ny, nz );
    if ((status = UNIX_CALL( glNormal3b, &args ))) WARN( "glNormal3b returned %#lx\n", status );
}

void WINAPI glNormal3bv( const GLbyte *v )
{
    struct glNormal3bv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glNormal3bv, &args ))) WARN( "glNormal3bv returned %#lx\n", status );
}

void WINAPI glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
{
    struct glNormal3d_params args = { .teb = NtCurrentTeb(), .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "nx %f, ny %f, nz %f\n", nx, ny, nz );
    if ((status = UNIX_CALL( glNormal3d, &args ))) WARN( "glNormal3d returned %#lx\n", status );
}

void WINAPI glNormal3dv( const GLdouble *v )
{
    struct glNormal3dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glNormal3dv, &args ))) WARN( "glNormal3dv returned %#lx\n", status );
}

void WINAPI glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
{
    struct glNormal3f_params args = { .teb = NtCurrentTeb(), .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "nx %f, ny %f, nz %f\n", nx, ny, nz );
    if ((status = UNIX_CALL( glNormal3f, &args ))) WARN( "glNormal3f returned %#lx\n", status );
}

void WINAPI glNormal3fv( const GLfloat *v )
{
    struct glNormal3fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glNormal3fv, &args ))) WARN( "glNormal3fv returned %#lx\n", status );
}

void WINAPI glNormal3i( GLint nx, GLint ny, GLint nz )
{
    struct glNormal3i_params args = { .teb = NtCurrentTeb(), .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "nx %d, ny %d, nz %d\n", nx, ny, nz );
    if ((status = UNIX_CALL( glNormal3i, &args ))) WARN( "glNormal3i returned %#lx\n", status );
}

void WINAPI glNormal3iv( const GLint *v )
{
    struct glNormal3iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glNormal3iv, &args ))) WARN( "glNormal3iv returned %#lx\n", status );
}

void WINAPI glNormal3s( GLshort nx, GLshort ny, GLshort nz )
{
    struct glNormal3s_params args = { .teb = NtCurrentTeb(), .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "nx %d, ny %d, nz %d\n", nx, ny, nz );
    if ((status = UNIX_CALL( glNormal3s, &args ))) WARN( "glNormal3s returned %#lx\n", status );
}

void WINAPI glNormal3sv( const GLshort *v )
{
    struct glNormal3sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glNormal3sv, &args ))) WARN( "glNormal3sv returned %#lx\n", status );
}

void WINAPI glNormalPointer( GLenum type, GLsizei stride, const void *pointer )
{
    struct glNormalPointer_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
    if ((status = UNIX_CALL( glNormalPointer, &args ))) WARN( "glNormalPointer returned %#lx\n", status );
}

void WINAPI glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
{
    struct glOrtho_params args = { .teb = NtCurrentTeb(), .left = left, .right = right, .bottom = bottom, .top = top, .zNear = zNear, .zFar = zFar };
    NTSTATUS status;
    TRACE( "left %f, right %f, bottom %f, top %f, zNear %f, zFar %f\n", left, right, bottom, top, zNear, zFar );
    if ((status = UNIX_CALL( glOrtho, &args ))) WARN( "glOrtho returned %#lx\n", status );
}

void WINAPI glPassThrough( GLfloat token )
{
    struct glPassThrough_params args = { .teb = NtCurrentTeb(), .token = token };
    NTSTATUS status;
    TRACE( "token %f\n", token );
    if ((status = UNIX_CALL( glPassThrough, &args ))) WARN( "glPassThrough returned %#lx\n", status );
}

void WINAPI glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
{
    struct glPixelMapfv_params args = { .teb = NtCurrentTeb(), .map = map, .mapsize = mapsize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, mapsize %d, values %p\n", map, mapsize, values );
    if ((status = UNIX_CALL( glPixelMapfv, &args ))) WARN( "glPixelMapfv returned %#lx\n", status );
}

void WINAPI glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values )
{
    struct glPixelMapuiv_params args = { .teb = NtCurrentTeb(), .map = map, .mapsize = mapsize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, mapsize %d, values %p\n", map, mapsize, values );
    if ((status = UNIX_CALL( glPixelMapuiv, &args ))) WARN( "glPixelMapuiv returned %#lx\n", status );
}

void WINAPI glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values )
{
    struct glPixelMapusv_params args = { .teb = NtCurrentTeb(), .map = map, .mapsize = mapsize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, mapsize %d, values %p\n", map, mapsize, values );
    if ((status = UNIX_CALL( glPixelMapusv, &args ))) WARN( "glPixelMapusv returned %#lx\n", status );
}

void WINAPI glPixelStoref( GLenum pname, GLfloat param )
{
    struct glPixelStoref_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glPixelStoref, &args ))) WARN( "glPixelStoref returned %#lx\n", status );
}

void WINAPI glPixelStorei( GLenum pname, GLint param )
{
    struct glPixelStorei_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glPixelStorei, &args ))) WARN( "glPixelStorei returned %#lx\n", status );
}

void WINAPI glPixelTransferf( GLenum pname, GLfloat param )
{
    struct glPixelTransferf_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glPixelTransferf, &args ))) WARN( "glPixelTransferf returned %#lx\n", status );
}

void WINAPI glPixelTransferi( GLenum pname, GLint param )
{
    struct glPixelTransferi_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glPixelTransferi, &args ))) WARN( "glPixelTransferi returned %#lx\n", status );
}

void WINAPI glPixelZoom( GLfloat xfactor, GLfloat yfactor )
{
    struct glPixelZoom_params args = { .teb = NtCurrentTeb(), .xfactor = xfactor, .yfactor = yfactor };
    NTSTATUS status;
    TRACE( "xfactor %f, yfactor %f\n", xfactor, yfactor );
    if ((status = UNIX_CALL( glPixelZoom, &args ))) WARN( "glPixelZoom returned %#lx\n", status );
}

void WINAPI glPointSize( GLfloat size )
{
    struct glPointSize_params args = { .teb = NtCurrentTeb(), .size = size };
    NTSTATUS status;
    TRACE( "size %f\n", size );
    if ((status = UNIX_CALL( glPointSize, &args ))) WARN( "glPointSize returned %#lx\n", status );
}

void WINAPI glPolygonMode( GLenum face, GLenum mode )
{
    struct glPolygonMode_params args = { .teb = NtCurrentTeb(), .face = face, .mode = mode };
    NTSTATUS status;
    TRACE( "face %d, mode %d\n", face, mode );
    if ((status = UNIX_CALL( glPolygonMode, &args ))) WARN( "glPolygonMode returned %#lx\n", status );
}

void WINAPI glPolygonOffset( GLfloat factor, GLfloat units )
{
    struct glPolygonOffset_params args = { .teb = NtCurrentTeb(), .factor = factor, .units = units };
    NTSTATUS status;
    TRACE( "factor %f, units %f\n", factor, units );
    if ((status = UNIX_CALL( glPolygonOffset, &args ))) WARN( "glPolygonOffset returned %#lx\n", status );
}

void WINAPI glPolygonStipple( const GLubyte *mask )
{
    struct glPolygonStipple_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %p\n", mask );
    if ((status = UNIX_CALL( glPolygonStipple, &args ))) WARN( "glPolygonStipple returned %#lx\n", status );
}

void WINAPI glPopAttrib(void)
{
    struct glPopAttrib_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPopAttrib, &args ))) WARN( "glPopAttrib returned %#lx\n", status );
}

void WINAPI glPopClientAttrib(void)
{
    struct glPopClientAttrib_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPopClientAttrib, &args ))) WARN( "glPopClientAttrib returned %#lx\n", status );
}

void WINAPI glPopMatrix(void)
{
    struct glPopMatrix_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPopMatrix, &args ))) WARN( "glPopMatrix returned %#lx\n", status );
}

void WINAPI glPopName(void)
{
    struct glPopName_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPopName, &args ))) WARN( "glPopName returned %#lx\n", status );
}

void WINAPI glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLfloat *priorities )
{
    struct glPrioritizeTextures_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures, .priorities = priorities };
    NTSTATUS status;
    TRACE( "n %d, textures %p, priorities %p\n", n, textures, priorities );
    if ((status = UNIX_CALL( glPrioritizeTextures, &args ))) WARN( "glPrioritizeTextures returned %#lx\n", status );
}

void WINAPI glPushAttrib( GLbitfield mask )
{
    struct glPushAttrib_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glPushAttrib, &args ))) WARN( "glPushAttrib returned %#lx\n", status );
}

void WINAPI glPushClientAttrib( GLbitfield mask )
{
    struct glPushClientAttrib_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glPushClientAttrib, &args ))) WARN( "glPushClientAttrib returned %#lx\n", status );
}

void WINAPI glPushMatrix(void)
{
    struct glPushMatrix_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPushMatrix, &args ))) WARN( "glPushMatrix returned %#lx\n", status );
}

void WINAPI glPushName( GLuint name )
{
    struct glPushName_params args = { .teb = NtCurrentTeb(), .name = name };
    NTSTATUS status;
    TRACE( "name %d\n", name );
    if ((status = UNIX_CALL( glPushName, &args ))) WARN( "glPushName returned %#lx\n", status );
}

void WINAPI glRasterPos2d( GLdouble x, GLdouble y )
{
    struct glRasterPos2d_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glRasterPos2d, &args ))) WARN( "glRasterPos2d returned %#lx\n", status );
}

void WINAPI glRasterPos2dv( const GLdouble *v )
{
    struct glRasterPos2dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos2dv, &args ))) WARN( "glRasterPos2dv returned %#lx\n", status );
}

void WINAPI glRasterPos2f( GLfloat x, GLfloat y )
{
    struct glRasterPos2f_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glRasterPos2f, &args ))) WARN( "glRasterPos2f returned %#lx\n", status );
}

void WINAPI glRasterPos2fv( const GLfloat *v )
{
    struct glRasterPos2fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos2fv, &args ))) WARN( "glRasterPos2fv returned %#lx\n", status );
}

void WINAPI glRasterPos2i( GLint x, GLint y )
{
    struct glRasterPos2i_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glRasterPos2i, &args ))) WARN( "glRasterPos2i returned %#lx\n", status );
}

void WINAPI glRasterPos2iv( const GLint *v )
{
    struct glRasterPos2iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos2iv, &args ))) WARN( "glRasterPos2iv returned %#lx\n", status );
}

void WINAPI glRasterPos2s( GLshort x, GLshort y )
{
    struct glRasterPos2s_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glRasterPos2s, &args ))) WARN( "glRasterPos2s returned %#lx\n", status );
}

void WINAPI glRasterPos2sv( const GLshort *v )
{
    struct glRasterPos2sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos2sv, &args ))) WARN( "glRasterPos2sv returned %#lx\n", status );
}

void WINAPI glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
{
    struct glRasterPos3d_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glRasterPos3d, &args ))) WARN( "glRasterPos3d returned %#lx\n", status );
}

void WINAPI glRasterPos3dv( const GLdouble *v )
{
    struct glRasterPos3dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos3dv, &args ))) WARN( "glRasterPos3dv returned %#lx\n", status );
}

void WINAPI glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
{
    struct glRasterPos3f_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glRasterPos3f, &args ))) WARN( "glRasterPos3f returned %#lx\n", status );
}

void WINAPI glRasterPos3fv( const GLfloat *v )
{
    struct glRasterPos3fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos3fv, &args ))) WARN( "glRasterPos3fv returned %#lx\n", status );
}

void WINAPI glRasterPos3i( GLint x, GLint y, GLint z )
{
    struct glRasterPos3i_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glRasterPos3i, &args ))) WARN( "glRasterPos3i returned %#lx\n", status );
}

void WINAPI glRasterPos3iv( const GLint *v )
{
    struct glRasterPos3iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos3iv, &args ))) WARN( "glRasterPos3iv returned %#lx\n", status );
}

void WINAPI glRasterPos3s( GLshort x, GLshort y, GLshort z )
{
    struct glRasterPos3s_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glRasterPos3s, &args ))) WARN( "glRasterPos3s returned %#lx\n", status );
}

void WINAPI glRasterPos3sv( const GLshort *v )
{
    struct glRasterPos3sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos3sv, &args ))) WARN( "glRasterPos3sv returned %#lx\n", status );
}

void WINAPI glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glRasterPos4d_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
    if ((status = UNIX_CALL( glRasterPos4d, &args ))) WARN( "glRasterPos4d returned %#lx\n", status );
}

void WINAPI glRasterPos4dv( const GLdouble *v )
{
    struct glRasterPos4dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos4dv, &args ))) WARN( "glRasterPos4dv returned %#lx\n", status );
}

void WINAPI glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glRasterPos4f_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
    if ((status = UNIX_CALL( glRasterPos4f, &args ))) WARN( "glRasterPos4f returned %#lx\n", status );
}

void WINAPI glRasterPos4fv( const GLfloat *v )
{
    struct glRasterPos4fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos4fv, &args ))) WARN( "glRasterPos4fv returned %#lx\n", status );
}

void WINAPI glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
{
    struct glRasterPos4i_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glRasterPos4i, &args ))) WARN( "glRasterPos4i returned %#lx\n", status );
}

void WINAPI glRasterPos4iv( const GLint *v )
{
    struct glRasterPos4iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos4iv, &args ))) WARN( "glRasterPos4iv returned %#lx\n", status );
}

void WINAPI glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
{
    struct glRasterPos4s_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glRasterPos4s, &args ))) WARN( "glRasterPos4s returned %#lx\n", status );
}

void WINAPI glRasterPos4sv( const GLshort *v )
{
    struct glRasterPos4sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glRasterPos4sv, &args ))) WARN( "glRasterPos4sv returned %#lx\n", status );
}

void WINAPI glReadBuffer( GLenum src )
{
    struct glReadBuffer_params args = { .teb = NtCurrentTeb(), .src = src };
    NTSTATUS status;
    TRACE( "src %d\n", src );
    if ((status = UNIX_CALL( glReadBuffer, &args ))) WARN( "glReadBuffer returned %#lx\n", status );
}

void WINAPI glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels )
{
    struct glReadPixels_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .width = width, .height = height, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "x %d, y %d, width %d, height %d, format %d, type %d, pixels %p\n", x, y, width, height, format, type, pixels );
    if ((status = UNIX_CALL( glReadPixels, &args ))) WARN( "glReadPixels returned %#lx\n", status );
}

void WINAPI glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
{
    struct glRectd_params args = { .teb = NtCurrentTeb(), .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2 };
    NTSTATUS status;
    TRACE( "x1 %f, y1 %f, x2 %f, y2 %f\n", x1, y1, x2, y2 );
    if ((status = UNIX_CALL( glRectd, &args ))) WARN( "glRectd returned %#lx\n", status );
}

void WINAPI glRectdv( const GLdouble *v1, const GLdouble *v2 )
{
    struct glRectdv_params args = { .teb = NtCurrentTeb(), .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "v1 %p, v2 %p\n", v1, v2 );
    if ((status = UNIX_CALL( glRectdv, &args ))) WARN( "glRectdv returned %#lx\n", status );
}

void WINAPI glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
{
    struct glRectf_params args = { .teb = NtCurrentTeb(), .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2 };
    NTSTATUS status;
    TRACE( "x1 %f, y1 %f, x2 %f, y2 %f\n", x1, y1, x2, y2 );
    if ((status = UNIX_CALL( glRectf, &args ))) WARN( "glRectf returned %#lx\n", status );
}

void WINAPI glRectfv( const GLfloat *v1, const GLfloat *v2 )
{
    struct glRectfv_params args = { .teb = NtCurrentTeb(), .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "v1 %p, v2 %p\n", v1, v2 );
    if ((status = UNIX_CALL( glRectfv, &args ))) WARN( "glRectfv returned %#lx\n", status );
}

void WINAPI glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
{
    struct glRecti_params args = { .teb = NtCurrentTeb(), .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2 };
    NTSTATUS status;
    TRACE( "x1 %d, y1 %d, x2 %d, y2 %d\n", x1, y1, x2, y2 );
    if ((status = UNIX_CALL( glRecti, &args ))) WARN( "glRecti returned %#lx\n", status );
}

void WINAPI glRectiv( const GLint *v1, const GLint *v2 )
{
    struct glRectiv_params args = { .teb = NtCurrentTeb(), .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "v1 %p, v2 %p\n", v1, v2 );
    if ((status = UNIX_CALL( glRectiv, &args ))) WARN( "glRectiv returned %#lx\n", status );
}

void WINAPI glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
{
    struct glRects_params args = { .teb = NtCurrentTeb(), .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2 };
    NTSTATUS status;
    TRACE( "x1 %d, y1 %d, x2 %d, y2 %d\n", x1, y1, x2, y2 );
    if ((status = UNIX_CALL( glRects, &args ))) WARN( "glRects returned %#lx\n", status );
}

void WINAPI glRectsv( const GLshort *v1, const GLshort *v2 )
{
    struct glRectsv_params args = { .teb = NtCurrentTeb(), .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "v1 %p, v2 %p\n", v1, v2 );
    if ((status = UNIX_CALL( glRectsv, &args ))) WARN( "glRectsv returned %#lx\n", status );
}

GLint WINAPI glRenderMode( GLenum mode )
{
    struct glRenderMode_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glRenderMode, &args ))) WARN( "glRenderMode returned %#lx\n", status );
    return args.ret;
}

void WINAPI glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
{
    struct glRotated_params args = { .teb = NtCurrentTeb(), .angle = angle, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "angle %f, x %f, y %f, z %f\n", angle, x, y, z );
    if ((status = UNIX_CALL( glRotated, &args ))) WARN( "glRotated returned %#lx\n", status );
}

void WINAPI glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
{
    struct glRotatef_params args = { .teb = NtCurrentTeb(), .angle = angle, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "angle %f, x %f, y %f, z %f\n", angle, x, y, z );
    if ((status = UNIX_CALL( glRotatef, &args ))) WARN( "glRotatef returned %#lx\n", status );
}

void WINAPI glScaled( GLdouble x, GLdouble y, GLdouble z )
{
    struct glScaled_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glScaled, &args ))) WARN( "glScaled returned %#lx\n", status );
}

void WINAPI glScalef( GLfloat x, GLfloat y, GLfloat z )
{
    struct glScalef_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glScalef, &args ))) WARN( "glScalef returned %#lx\n", status );
}

void WINAPI glScissor( GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glScissor_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "x %d, y %d, width %d, height %d\n", x, y, width, height );
    if ((status = UNIX_CALL( glScissor, &args ))) WARN( "glScissor returned %#lx\n", status );
}

void WINAPI glSelectBuffer( GLsizei size, GLuint *buffer )
{
    struct glSelectBuffer_params args = { .teb = NtCurrentTeb(), .size = size, .buffer = buffer };
    NTSTATUS status;
    TRACE( "size %d, buffer %p\n", size, buffer );
    if ((status = UNIX_CALL( glSelectBuffer, &args ))) WARN( "glSelectBuffer returned %#lx\n", status );
}

void WINAPI glShadeModel( GLenum mode )
{
    struct glShadeModel_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glShadeModel, &args ))) WARN( "glShadeModel returned %#lx\n", status );
}

void WINAPI glStencilFunc( GLenum func, GLint ref, GLuint mask )
{
    struct glStencilFunc_params args = { .teb = NtCurrentTeb(), .func = func, .ref = ref, .mask = mask };
    NTSTATUS status;
    TRACE( "func %d, ref %d, mask %d\n", func, ref, mask );
    if ((status = UNIX_CALL( glStencilFunc, &args ))) WARN( "glStencilFunc returned %#lx\n", status );
}

void WINAPI glStencilMask( GLuint mask )
{
    struct glStencilMask_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glStencilMask, &args ))) WARN( "glStencilMask returned %#lx\n", status );
}

void WINAPI glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
{
    struct glStencilOp_params args = { .teb = NtCurrentTeb(), .fail = fail, .zfail = zfail, .zpass = zpass };
    NTSTATUS status;
    TRACE( "fail %d, zfail %d, zpass %d\n", fail, zfail, zpass );
    if ((status = UNIX_CALL( glStencilOp, &args ))) WARN( "glStencilOp returned %#lx\n", status );
}

void WINAPI glTexCoord1d( GLdouble s )
{
    struct glTexCoord1d_params args = { .teb = NtCurrentTeb(), .s = s };
    NTSTATUS status;
    TRACE( "s %f\n", s );
    if ((status = UNIX_CALL( glTexCoord1d, &args ))) WARN( "glTexCoord1d returned %#lx\n", status );
}

void WINAPI glTexCoord1dv( const GLdouble *v )
{
    struct glTexCoord1dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord1dv, &args ))) WARN( "glTexCoord1dv returned %#lx\n", status );
}

void WINAPI glTexCoord1f( GLfloat s )
{
    struct glTexCoord1f_params args = { .teb = NtCurrentTeb(), .s = s };
    NTSTATUS status;
    TRACE( "s %f\n", s );
    if ((status = UNIX_CALL( glTexCoord1f, &args ))) WARN( "glTexCoord1f returned %#lx\n", status );
}

void WINAPI glTexCoord1fv( const GLfloat *v )
{
    struct glTexCoord1fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord1fv, &args ))) WARN( "glTexCoord1fv returned %#lx\n", status );
}

void WINAPI glTexCoord1i( GLint s )
{
    struct glTexCoord1i_params args = { .teb = NtCurrentTeb(), .s = s };
    NTSTATUS status;
    TRACE( "s %d\n", s );
    if ((status = UNIX_CALL( glTexCoord1i, &args ))) WARN( "glTexCoord1i returned %#lx\n", status );
}

void WINAPI glTexCoord1iv( const GLint *v )
{
    struct glTexCoord1iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord1iv, &args ))) WARN( "glTexCoord1iv returned %#lx\n", status );
}

void WINAPI glTexCoord1s( GLshort s )
{
    struct glTexCoord1s_params args = { .teb = NtCurrentTeb(), .s = s };
    NTSTATUS status;
    TRACE( "s %d\n", s );
    if ((status = UNIX_CALL( glTexCoord1s, &args ))) WARN( "glTexCoord1s returned %#lx\n", status );
}

void WINAPI glTexCoord1sv( const GLshort *v )
{
    struct glTexCoord1sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord1sv, &args ))) WARN( "glTexCoord1sv returned %#lx\n", status );
}

void WINAPI glTexCoord2d( GLdouble s, GLdouble t )
{
    struct glTexCoord2d_params args = { .teb = NtCurrentTeb(), .s = s, .t = t };
    NTSTATUS status;
    TRACE( "s %f, t %f\n", s, t );
    if ((status = UNIX_CALL( glTexCoord2d, &args ))) WARN( "glTexCoord2d returned %#lx\n", status );
}

void WINAPI glTexCoord2dv( const GLdouble *v )
{
    struct glTexCoord2dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord2dv, &args ))) WARN( "glTexCoord2dv returned %#lx\n", status );
}

void WINAPI glTexCoord2f( GLfloat s, GLfloat t )
{
    struct glTexCoord2f_params args = { .teb = NtCurrentTeb(), .s = s, .t = t };
    NTSTATUS status;
    TRACE( "s %f, t %f\n", s, t );
    if ((status = UNIX_CALL( glTexCoord2f, &args ))) WARN( "glTexCoord2f returned %#lx\n", status );
}

void WINAPI glTexCoord2fv( const GLfloat *v )
{
    struct glTexCoord2fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord2fv, &args ))) WARN( "glTexCoord2fv returned %#lx\n", status );
}

void WINAPI glTexCoord2i( GLint s, GLint t )
{
    struct glTexCoord2i_params args = { .teb = NtCurrentTeb(), .s = s, .t = t };
    NTSTATUS status;
    TRACE( "s %d, t %d\n", s, t );
    if ((status = UNIX_CALL( glTexCoord2i, &args ))) WARN( "glTexCoord2i returned %#lx\n", status );
}

void WINAPI glTexCoord2iv( const GLint *v )
{
    struct glTexCoord2iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord2iv, &args ))) WARN( "glTexCoord2iv returned %#lx\n", status );
}

void WINAPI glTexCoord2s( GLshort s, GLshort t )
{
    struct glTexCoord2s_params args = { .teb = NtCurrentTeb(), .s = s, .t = t };
    NTSTATUS status;
    TRACE( "s %d, t %d\n", s, t );
    if ((status = UNIX_CALL( glTexCoord2s, &args ))) WARN( "glTexCoord2s returned %#lx\n", status );
}

void WINAPI glTexCoord2sv( const GLshort *v )
{
    struct glTexCoord2sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord2sv, &args ))) WARN( "glTexCoord2sv returned %#lx\n", status );
}

void WINAPI glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
{
    struct glTexCoord3d_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "s %f, t %f, r %f\n", s, t, r );
    if ((status = UNIX_CALL( glTexCoord3d, &args ))) WARN( "glTexCoord3d returned %#lx\n", status );
}

void WINAPI glTexCoord3dv( const GLdouble *v )
{
    struct glTexCoord3dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord3dv, &args ))) WARN( "glTexCoord3dv returned %#lx\n", status );
}

void WINAPI glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
{
    struct glTexCoord3f_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "s %f, t %f, r %f\n", s, t, r );
    if ((status = UNIX_CALL( glTexCoord3f, &args ))) WARN( "glTexCoord3f returned %#lx\n", status );
}

void WINAPI glTexCoord3fv( const GLfloat *v )
{
    struct glTexCoord3fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord3fv, &args ))) WARN( "glTexCoord3fv returned %#lx\n", status );
}

void WINAPI glTexCoord3i( GLint s, GLint t, GLint r )
{
    struct glTexCoord3i_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d\n", s, t, r );
    if ((status = UNIX_CALL( glTexCoord3i, &args ))) WARN( "glTexCoord3i returned %#lx\n", status );
}

void WINAPI glTexCoord3iv( const GLint *v )
{
    struct glTexCoord3iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord3iv, &args ))) WARN( "glTexCoord3iv returned %#lx\n", status );
}

void WINAPI glTexCoord3s( GLshort s, GLshort t, GLshort r )
{
    struct glTexCoord3s_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d\n", s, t, r );
    if ((status = UNIX_CALL( glTexCoord3s, &args ))) WARN( "glTexCoord3s returned %#lx\n", status );
}

void WINAPI glTexCoord3sv( const GLshort *v )
{
    struct glTexCoord3sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord3sv, &args ))) WARN( "glTexCoord3sv returned %#lx\n", status );
}

void WINAPI glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
{
    struct glTexCoord4d_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "s %f, t %f, r %f, q %f\n", s, t, r, q );
    if ((status = UNIX_CALL( glTexCoord4d, &args ))) WARN( "glTexCoord4d returned %#lx\n", status );
}

void WINAPI glTexCoord4dv( const GLdouble *v )
{
    struct glTexCoord4dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord4dv, &args ))) WARN( "glTexCoord4dv returned %#lx\n", status );
}

void WINAPI glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
{
    struct glTexCoord4f_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "s %f, t %f, r %f, q %f\n", s, t, r, q );
    if ((status = UNIX_CALL( glTexCoord4f, &args ))) WARN( "glTexCoord4f returned %#lx\n", status );
}

void WINAPI glTexCoord4fv( const GLfloat *v )
{
    struct glTexCoord4fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord4fv, &args ))) WARN( "glTexCoord4fv returned %#lx\n", status );
}

void WINAPI glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
{
    struct glTexCoord4i_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d, q %d\n", s, t, r, q );
    if ((status = UNIX_CALL( glTexCoord4i, &args ))) WARN( "glTexCoord4i returned %#lx\n", status );
}

void WINAPI glTexCoord4iv( const GLint *v )
{
    struct glTexCoord4iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord4iv, &args ))) WARN( "glTexCoord4iv returned %#lx\n", status );
}

void WINAPI glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
{
    struct glTexCoord4s_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d, q %d\n", s, t, r, q );
    if ((status = UNIX_CALL( glTexCoord4s, &args ))) WARN( "glTexCoord4s returned %#lx\n", status );
}

void WINAPI glTexCoord4sv( const GLshort *v )
{
    struct glTexCoord4sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord4sv, &args ))) WARN( "glTexCoord4sv returned %#lx\n", status );
}

void WINAPI glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glTexCoordPointer_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
    if ((status = UNIX_CALL( glTexCoordPointer, &args ))) WARN( "glTexCoordPointer returned %#lx\n", status );
}

void WINAPI glTexEnvf( GLenum target, GLenum pname, GLfloat param )
{
    struct glTexEnvf_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %f\n", target, pname, param );
    if ((status = UNIX_CALL( glTexEnvf, &args ))) WARN( "glTexEnvf returned %#lx\n", status );
}

void WINAPI glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glTexEnvfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexEnvfv, &args ))) WARN( "glTexEnvfv returned %#lx\n", status );
}

void WINAPI glTexEnvi( GLenum target, GLenum pname, GLint param )
{
    struct glTexEnvi_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glTexEnvi, &args ))) WARN( "glTexEnvi returned %#lx\n", status );
}

void WINAPI glTexEnviv( GLenum target, GLenum pname, const GLint *params )
{
    struct glTexEnviv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexEnviv, &args ))) WARN( "glTexEnviv returned %#lx\n", status );
}

void WINAPI glTexGend( GLenum coord, GLenum pname, GLdouble param )
{
    struct glTexGend_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, param %f\n", coord, pname, param );
    if ((status = UNIX_CALL( glTexGend, &args ))) WARN( "glTexGend returned %#lx\n", status );
}

void WINAPI glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
{
    struct glTexGendv_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
    if ((status = UNIX_CALL( glTexGendv, &args ))) WARN( "glTexGendv returned %#lx\n", status );
}

void WINAPI glTexGenf( GLenum coord, GLenum pname, GLfloat param )
{
    struct glTexGenf_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, param %f\n", coord, pname, param );
    if ((status = UNIX_CALL( glTexGenf, &args ))) WARN( "glTexGenf returned %#lx\n", status );
}

void WINAPI glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
{
    struct glTexGenfv_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
    if ((status = UNIX_CALL( glTexGenfv, &args ))) WARN( "glTexGenfv returned %#lx\n", status );
}

void WINAPI glTexGeni( GLenum coord, GLenum pname, GLint param )
{
    struct glTexGeni_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, param %d\n", coord, pname, param );
    if ((status = UNIX_CALL( glTexGeni, &args ))) WARN( "glTexGeni returned %#lx\n", status );
}

void WINAPI glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
{
    struct glTexGeniv_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
    if ((status = UNIX_CALL( glTexGeniv, &args ))) WARN( "glTexGeniv returned %#lx\n", status );
}

void WINAPI glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glTexImage1D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, border %d, format %d, type %d, pixels %p\n", target, level, internalformat, width, border, format, type, pixels );
    if ((status = UNIX_CALL( glTexImage1D, &args ))) WARN( "glTexImage1D returned %#lx\n", status );
}

void WINAPI glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glTexImage2D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, border %d, format %d, type %d, pixels %p\n", target, level, internalformat, width, height, border, format, type, pixels );
    if ((status = UNIX_CALL( glTexImage2D, &args ))) WARN( "glTexImage2D returned %#lx\n", status );
}

void WINAPI glTexParameterf( GLenum target, GLenum pname, GLfloat param )
{
    struct glTexParameterf_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %f\n", target, pname, param );
    if ((status = UNIX_CALL( glTexParameterf, &args ))) WARN( "glTexParameterf returned %#lx\n", status );
}

void WINAPI glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glTexParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexParameterfv, &args ))) WARN( "glTexParameterfv returned %#lx\n", status );
}

void WINAPI glTexParameteri( GLenum target, GLenum pname, GLint param )
{
    struct glTexParameteri_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glTexParameteri, &args ))) WARN( "glTexParameteri returned %#lx\n", status );
}

void WINAPI glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
{
    struct glTexParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexParameteriv, &args ))) WARN( "glTexParameteriv returned %#lx\n", status );
}

void WINAPI glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
{
    struct glTexSubImage1D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, width %d, format %d, type %d, pixels %p\n", target, level, xoffset, width, format, type, pixels );
    if ((status = UNIX_CALL( glTexSubImage1D, &args ))) WARN( "glTexSubImage1D returned %#lx\n", status );
}

void WINAPI glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
{
    struct glTexSubImage2D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, type %d, pixels %p\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
    if ((status = UNIX_CALL( glTexSubImage2D, &args ))) WARN( "glTexSubImage2D returned %#lx\n", status );
}

void WINAPI glTranslated( GLdouble x, GLdouble y, GLdouble z )
{
    struct glTranslated_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glTranslated, &args ))) WARN( "glTranslated returned %#lx\n", status );
}

void WINAPI glTranslatef( GLfloat x, GLfloat y, GLfloat z )
{
    struct glTranslatef_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glTranslatef, &args ))) WARN( "glTranslatef returned %#lx\n", status );
}

void WINAPI glVertex2d( GLdouble x, GLdouble y )
{
    struct glVertex2d_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glVertex2d, &args ))) WARN( "glVertex2d returned %#lx\n", status );
}

void WINAPI glVertex2dv( const GLdouble *v )
{
    struct glVertex2dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex2dv, &args ))) WARN( "glVertex2dv returned %#lx\n", status );
}

void WINAPI glVertex2f( GLfloat x, GLfloat y )
{
    struct glVertex2f_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glVertex2f, &args ))) WARN( "glVertex2f returned %#lx\n", status );
}

void WINAPI glVertex2fv( const GLfloat *v )
{
    struct glVertex2fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex2fv, &args ))) WARN( "glVertex2fv returned %#lx\n", status );
}

void WINAPI glVertex2i( GLint x, GLint y )
{
    struct glVertex2i_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glVertex2i, &args ))) WARN( "glVertex2i returned %#lx\n", status );
}

void WINAPI glVertex2iv( const GLint *v )
{
    struct glVertex2iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex2iv, &args ))) WARN( "glVertex2iv returned %#lx\n", status );
}

void WINAPI glVertex2s( GLshort x, GLshort y )
{
    struct glVertex2s_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glVertex2s, &args ))) WARN( "glVertex2s returned %#lx\n", status );
}

void WINAPI glVertex2sv( const GLshort *v )
{
    struct glVertex2sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex2sv, &args ))) WARN( "glVertex2sv returned %#lx\n", status );
}

void WINAPI glVertex3d( GLdouble x, GLdouble y, GLdouble z )
{
    struct glVertex3d_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glVertex3d, &args ))) WARN( "glVertex3d returned %#lx\n", status );
}

void WINAPI glVertex3dv( const GLdouble *v )
{
    struct glVertex3dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex3dv, &args ))) WARN( "glVertex3dv returned %#lx\n", status );
}

void WINAPI glVertex3f( GLfloat x, GLfloat y, GLfloat z )
{
    struct glVertex3f_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glVertex3f, &args ))) WARN( "glVertex3f returned %#lx\n", status );
}

void WINAPI glVertex3fv( const GLfloat *v )
{
    struct glVertex3fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex3fv, &args ))) WARN( "glVertex3fv returned %#lx\n", status );
}

void WINAPI glVertex3i( GLint x, GLint y, GLint z )
{
    struct glVertex3i_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glVertex3i, &args ))) WARN( "glVertex3i returned %#lx\n", status );
}

void WINAPI glVertex3iv( const GLint *v )
{
    struct glVertex3iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex3iv, &args ))) WARN( "glVertex3iv returned %#lx\n", status );
}

void WINAPI glVertex3s( GLshort x, GLshort y, GLshort z )
{
    struct glVertex3s_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glVertex3s, &args ))) WARN( "glVertex3s returned %#lx\n", status );
}

void WINAPI glVertex3sv( const GLshort *v )
{
    struct glVertex3sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex3sv, &args ))) WARN( "glVertex3sv returned %#lx\n", status );
}

void WINAPI glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glVertex4d_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
    if ((status = UNIX_CALL( glVertex4d, &args ))) WARN( "glVertex4d returned %#lx\n", status );
}

void WINAPI glVertex4dv( const GLdouble *v )
{
    struct glVertex4dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex4dv, &args ))) WARN( "glVertex4dv returned %#lx\n", status );
}

void WINAPI glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glVertex4f_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
    if ((status = UNIX_CALL( glVertex4f, &args ))) WARN( "glVertex4f returned %#lx\n", status );
}

void WINAPI glVertex4fv( const GLfloat *v )
{
    struct glVertex4fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex4fv, &args ))) WARN( "glVertex4fv returned %#lx\n", status );
}

void WINAPI glVertex4i( GLint x, GLint y, GLint z, GLint w )
{
    struct glVertex4i_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glVertex4i, &args ))) WARN( "glVertex4i returned %#lx\n", status );
}

void WINAPI glVertex4iv( const GLint *v )
{
    struct glVertex4iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex4iv, &args ))) WARN( "glVertex4iv returned %#lx\n", status );
}

void WINAPI glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
{
    struct glVertex4s_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glVertex4s, &args ))) WARN( "glVertex4s returned %#lx\n", status );
}

void WINAPI glVertex4sv( const GLshort *v )
{
    struct glVertex4sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex4sv, &args ))) WARN( "glVertex4sv returned %#lx\n", status );
}

void WINAPI glVertexPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glVertexPointer_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
    if ((status = UNIX_CALL( glVertexPointer, &args ))) WARN( "glVertexPointer returned %#lx\n", status );
}

void WINAPI glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glViewport_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "x %d, y %d, width %d, height %d\n", x, y, width, height );
    if ((status = UNIX_CALL( glViewport, &args ))) WARN( "glViewport returned %#lx\n", status );
}

static void WINAPI glAccumxOES( GLenum op, GLfixed value )
{
    struct glAccumxOES_params args = { .teb = NtCurrentTeb(), .op = op, .value = value };
    NTSTATUS status;
    TRACE( "op %d, value %d\n", op, value );
    if ((status = UNIX_CALL( glAccumxOES, &args ))) WARN( "glAccumxOES returned %#lx\n", status );
}

static GLboolean WINAPI glAcquireKeyedMutexWin32EXT( GLuint memory, GLuint64 key, GLuint timeout )
{
    struct glAcquireKeyedMutexWin32EXT_params args = { .teb = NtCurrentTeb(), .memory = memory, .key = key, .timeout = timeout };
    NTSTATUS status;
    TRACE( "memory %d, key %s, timeout %d\n", memory, wine_dbgstr_longlong(key), timeout );
    if ((status = UNIX_CALL( glAcquireKeyedMutexWin32EXT, &args ))) WARN( "glAcquireKeyedMutexWin32EXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glActiveProgramEXT( GLuint program )
{
    struct glActiveProgramEXT_params args = { .teb = NtCurrentTeb(), .program = program };
    NTSTATUS status;
    TRACE( "program %d\n", program );
    if ((status = UNIX_CALL( glActiveProgramEXT, &args ))) WARN( "glActiveProgramEXT returned %#lx\n", status );
}

static void WINAPI glActiveShaderProgram( GLuint pipeline, GLuint program )
{
    struct glActiveShaderProgram_params args = { .teb = NtCurrentTeb(), .pipeline = pipeline, .program = program };
    NTSTATUS status;
    TRACE( "pipeline %d, program %d\n", pipeline, program );
    if ((status = UNIX_CALL( glActiveShaderProgram, &args ))) WARN( "glActiveShaderProgram returned %#lx\n", status );
}

static void WINAPI glActiveStencilFaceEXT( GLenum face )
{
    struct glActiveStencilFaceEXT_params args = { .teb = NtCurrentTeb(), .face = face };
    NTSTATUS status;
    TRACE( "face %d\n", face );
    if ((status = UNIX_CALL( glActiveStencilFaceEXT, &args ))) WARN( "glActiveStencilFaceEXT returned %#lx\n", status );
}

static void WINAPI glActiveTexture( GLenum texture )
{
    struct glActiveTexture_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glActiveTexture, &args ))) WARN( "glActiveTexture returned %#lx\n", status );
}

static void WINAPI glActiveTextureARB( GLenum texture )
{
    struct glActiveTextureARB_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glActiveTextureARB, &args ))) WARN( "glActiveTextureARB returned %#lx\n", status );
}

static void WINAPI glActiveVaryingNV( GLuint program, const GLchar *name )
{
    struct glActiveVaryingNV_params args = { .teb = NtCurrentTeb(), .program = program, .name = name };
    NTSTATUS status;
    TRACE( "program %d, name %p\n", program, name );
    if ((status = UNIX_CALL( glActiveVaryingNV, &args ))) WARN( "glActiveVaryingNV returned %#lx\n", status );
}

static void WINAPI glAlphaFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod )
{
    struct glAlphaFragmentOp1ATI_params args = { .teb = NtCurrentTeb(), .op = op, .dst = dst, .dstMod = dstMod, .arg1 = arg1, .arg1Rep = arg1Rep, .arg1Mod = arg1Mod };
    NTSTATUS status;
    TRACE( "op %d, dst %d, dstMod %d, arg1 %d, arg1Rep %d, arg1Mod %d\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod );
    if ((status = UNIX_CALL( glAlphaFragmentOp1ATI, &args ))) WARN( "glAlphaFragmentOp1ATI returned %#lx\n", status );
}

static void WINAPI glAlphaFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod )
{
    struct glAlphaFragmentOp2ATI_params args = { .teb = NtCurrentTeb(), .op = op, .dst = dst, .dstMod = dstMod, .arg1 = arg1, .arg1Rep = arg1Rep, .arg1Mod = arg1Mod, .arg2 = arg2, .arg2Rep = arg2Rep, .arg2Mod = arg2Mod };
    NTSTATUS status;
    TRACE( "op %d, dst %d, dstMod %d, arg1 %d, arg1Rep %d, arg1Mod %d, arg2 %d, arg2Rep %d, arg2Mod %d\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod );
    if ((status = UNIX_CALL( glAlphaFragmentOp2ATI, &args ))) WARN( "glAlphaFragmentOp2ATI returned %#lx\n", status );
}

static void WINAPI glAlphaFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod )
{
    struct glAlphaFragmentOp3ATI_params args = { .teb = NtCurrentTeb(), .op = op, .dst = dst, .dstMod = dstMod, .arg1 = arg1, .arg1Rep = arg1Rep, .arg1Mod = arg1Mod, .arg2 = arg2, .arg2Rep = arg2Rep, .arg2Mod = arg2Mod, .arg3 = arg3, .arg3Rep = arg3Rep, .arg3Mod = arg3Mod };
    NTSTATUS status;
    TRACE( "op %d, dst %d, dstMod %d, arg1 %d, arg1Rep %d, arg1Mod %d, arg2 %d, arg2Rep %d, arg2Mod %d, arg3 %d, arg3Rep %d, arg3Mod %d\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod );
    if ((status = UNIX_CALL( glAlphaFragmentOp3ATI, &args ))) WARN( "glAlphaFragmentOp3ATI returned %#lx\n", status );
}

static void WINAPI glAlphaFuncxOES( GLenum func, GLfixed ref )
{
    struct glAlphaFuncxOES_params args = { .teb = NtCurrentTeb(), .func = func, .ref = ref };
    NTSTATUS status;
    TRACE( "func %d, ref %d\n", func, ref );
    if ((status = UNIX_CALL( glAlphaFuncxOES, &args ))) WARN( "glAlphaFuncxOES returned %#lx\n", status );
}

static void WINAPI glAlphaToCoverageDitherControlNV( GLenum mode )
{
    struct glAlphaToCoverageDitherControlNV_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glAlphaToCoverageDitherControlNV, &args ))) WARN( "glAlphaToCoverageDitherControlNV returned %#lx\n", status );
}

static void WINAPI glApplyFramebufferAttachmentCMAAINTEL(void)
{
    struct glApplyFramebufferAttachmentCMAAINTEL_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glApplyFramebufferAttachmentCMAAINTEL, &args ))) WARN( "glApplyFramebufferAttachmentCMAAINTEL returned %#lx\n", status );
}

static void WINAPI glApplyTextureEXT( GLenum mode )
{
    struct glApplyTextureEXT_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glApplyTextureEXT, &args ))) WARN( "glApplyTextureEXT returned %#lx\n", status );
}

static GLboolean WINAPI glAreProgramsResidentNV( GLsizei n, const GLuint *programs, GLboolean *residences )
{
    struct glAreProgramsResidentNV_params args = { .teb = NtCurrentTeb(), .n = n, .programs = programs, .residences = residences };
    NTSTATUS status;
    TRACE( "n %d, programs %p, residences %p\n", n, programs, residences );
    if ((status = UNIX_CALL( glAreProgramsResidentNV, &args ))) WARN( "glAreProgramsResidentNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glAreTexturesResidentEXT( GLsizei n, const GLuint *textures, GLboolean *residences )
{
    struct glAreTexturesResidentEXT_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures, .residences = residences };
    NTSTATUS status;
    TRACE( "n %d, textures %p, residences %p\n", n, textures, residences );
    if ((status = UNIX_CALL( glAreTexturesResidentEXT, &args ))) WARN( "glAreTexturesResidentEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glArrayElementEXT( GLint i )
{
    struct glArrayElementEXT_params args = { .teb = NtCurrentTeb(), .i = i };
    NTSTATUS status;
    TRACE( "i %d\n", i );
    if ((status = UNIX_CALL( glArrayElementEXT, &args ))) WARN( "glArrayElementEXT returned %#lx\n", status );
}

static void WINAPI glArrayObjectATI( GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset )
{
    struct glArrayObjectATI_params args = { .teb = NtCurrentTeb(), .array = array, .size = size, .type = type, .stride = stride, .buffer = buffer, .offset = offset };
    NTSTATUS status;
    TRACE( "array %d, size %d, type %d, stride %d, buffer %d, offset %d\n", array, size, type, stride, buffer, offset );
    if ((status = UNIX_CALL( glArrayObjectATI, &args ))) WARN( "glArrayObjectATI returned %#lx\n", status );
}

static GLuint WINAPI glAsyncCopyBufferSubDataNVX( GLsizei waitSemaphoreCount, const GLuint *waitSemaphoreArray, const GLuint64 *fenceValueArray, GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size, GLsizei signalSemaphoreCount, const GLuint *signalSemaphoreArray, const GLuint64 *signalValueArray )
{
    struct glAsyncCopyBufferSubDataNVX_params args = { .teb = NtCurrentTeb(), .waitSemaphoreCount = waitSemaphoreCount, .waitSemaphoreArray = waitSemaphoreArray, .fenceValueArray = fenceValueArray, .readGpu = readGpu, .writeGpuMask = writeGpuMask, .readBuffer = readBuffer, .writeBuffer = writeBuffer, .readOffset = readOffset, .writeOffset = writeOffset, .size = size, .signalSemaphoreCount = signalSemaphoreCount, .signalSemaphoreArray = signalSemaphoreArray, .signalValueArray = signalValueArray };
    NTSTATUS status;
    TRACE( "waitSemaphoreCount %d, waitSemaphoreArray %p, fenceValueArray %p, readGpu %d, writeGpuMask %d, readBuffer %d, writeBuffer %d, readOffset %Id, writeOffset %Id, size %Id, signalSemaphoreCount %d, signalSemaphoreArray %p, signalValueArray %p\n", waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray );
    if ((status = UNIX_CALL( glAsyncCopyBufferSubDataNVX, &args ))) WARN( "glAsyncCopyBufferSubDataNVX returned %#lx\n", status );
    return args.ret;
}

static GLuint WINAPI glAsyncCopyImageSubDataNVX( GLsizei waitSemaphoreCount, const GLuint *waitSemaphoreArray, const GLuint64 *waitValueArray, GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth, GLsizei signalSemaphoreCount, const GLuint *signalSemaphoreArray, const GLuint64 *signalValueArray )
{
    struct glAsyncCopyImageSubDataNVX_params args = { .teb = NtCurrentTeb(), .waitSemaphoreCount = waitSemaphoreCount, .waitSemaphoreArray = waitSemaphoreArray, .waitValueArray = waitValueArray, .srcGpu = srcGpu, .dstGpuMask = dstGpuMask, .srcName = srcName, .srcTarget = srcTarget, .srcLevel = srcLevel, .srcX = srcX, .srcY = srcY, .srcZ = srcZ, .dstName = dstName, .dstTarget = dstTarget, .dstLevel = dstLevel, .dstX = dstX, .dstY = dstY, .dstZ = dstZ, .srcWidth = srcWidth, .srcHeight = srcHeight, .srcDepth = srcDepth, .signalSemaphoreCount = signalSemaphoreCount, .signalSemaphoreArray = signalSemaphoreArray, .signalValueArray = signalValueArray };
    NTSTATUS status;
    TRACE( "waitSemaphoreCount %d, waitSemaphoreArray %p, waitValueArray %p, srcGpu %d, dstGpuMask %d, srcName %d, srcTarget %d, srcLevel %d, srcX %d, srcY %d, srcZ %d, dstName %d, dstTarget %d, dstLevel %d, dstX %d, dstY %d, dstZ %d, srcWidth %d, srcHeight %d, srcDepth %d, signalSemaphoreCount %d, signalSemaphoreArray %p, signalValueArray %p\n", waitSemaphoreCount, waitSemaphoreArray, waitValueArray, srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth, signalSemaphoreCount, signalSemaphoreArray, signalValueArray );
    if ((status = UNIX_CALL( glAsyncCopyImageSubDataNVX, &args ))) WARN( "glAsyncCopyImageSubDataNVX returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glAsyncMarkerSGIX( GLuint marker )
{
    struct glAsyncMarkerSGIX_params args = { .teb = NtCurrentTeb(), .marker = marker };
    NTSTATUS status;
    TRACE( "marker %d\n", marker );
    if ((status = UNIX_CALL( glAsyncMarkerSGIX, &args ))) WARN( "glAsyncMarkerSGIX returned %#lx\n", status );
}

static void WINAPI glAttachObjectARB( GLhandleARB containerObj, GLhandleARB obj )
{
    struct glAttachObjectARB_params args = { .teb = NtCurrentTeb(), .containerObj = containerObj, .obj = obj };
    NTSTATUS status;
    TRACE( "containerObj %d, obj %d\n", containerObj, obj );
    if ((status = UNIX_CALL( glAttachObjectARB, &args ))) WARN( "glAttachObjectARB returned %#lx\n", status );
}

static void WINAPI glAttachShader( GLuint program, GLuint shader )
{
    struct glAttachShader_params args = { .teb = NtCurrentTeb(), .program = program, .shader = shader };
    NTSTATUS status;
    TRACE( "program %d, shader %d\n", program, shader );
    if ((status = UNIX_CALL( glAttachShader, &args ))) WARN( "glAttachShader returned %#lx\n", status );
}

static void WINAPI glBeginConditionalRender( GLuint id, GLenum mode )
{
    struct glBeginConditionalRender_params args = { .teb = NtCurrentTeb(), .id = id, .mode = mode };
    NTSTATUS status;
    TRACE( "id %d, mode %d\n", id, mode );
    if ((status = UNIX_CALL( glBeginConditionalRender, &args ))) WARN( "glBeginConditionalRender returned %#lx\n", status );
}

static void WINAPI glBeginConditionalRenderNV( GLuint id, GLenum mode )
{
    struct glBeginConditionalRenderNV_params args = { .teb = NtCurrentTeb(), .id = id, .mode = mode };
    NTSTATUS status;
    TRACE( "id %d, mode %d\n", id, mode );
    if ((status = UNIX_CALL( glBeginConditionalRenderNV, &args ))) WARN( "glBeginConditionalRenderNV returned %#lx\n", status );
}

static void WINAPI glBeginConditionalRenderNVX( GLuint id )
{
    struct glBeginConditionalRenderNVX_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glBeginConditionalRenderNVX, &args ))) WARN( "glBeginConditionalRenderNVX returned %#lx\n", status );
}

static void WINAPI glBeginFragmentShaderATI(void)
{
    struct glBeginFragmentShaderATI_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glBeginFragmentShaderATI, &args ))) WARN( "glBeginFragmentShaderATI returned %#lx\n", status );
}

static void WINAPI glBeginOcclusionQueryNV( GLuint id )
{
    struct glBeginOcclusionQueryNV_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glBeginOcclusionQueryNV, &args ))) WARN( "glBeginOcclusionQueryNV returned %#lx\n", status );
}

static void WINAPI glBeginPerfMonitorAMD( GLuint monitor )
{
    struct glBeginPerfMonitorAMD_params args = { .teb = NtCurrentTeb(), .monitor = monitor };
    NTSTATUS status;
    TRACE( "monitor %d\n", monitor );
    if ((status = UNIX_CALL( glBeginPerfMonitorAMD, &args ))) WARN( "glBeginPerfMonitorAMD returned %#lx\n", status );
}

static void WINAPI glBeginPerfQueryINTEL( GLuint queryHandle )
{
    struct glBeginPerfQueryINTEL_params args = { .teb = NtCurrentTeb(), .queryHandle = queryHandle };
    NTSTATUS status;
    TRACE( "queryHandle %d\n", queryHandle );
    if ((status = UNIX_CALL( glBeginPerfQueryINTEL, &args ))) WARN( "glBeginPerfQueryINTEL returned %#lx\n", status );
}

static void WINAPI glBeginQuery( GLenum target, GLuint id )
{
    struct glBeginQuery_params args = { .teb = NtCurrentTeb(), .target = target, .id = id };
    NTSTATUS status;
    TRACE( "target %d, id %d\n", target, id );
    if ((status = UNIX_CALL( glBeginQuery, &args ))) WARN( "glBeginQuery returned %#lx\n", status );
}

static void WINAPI glBeginQueryARB( GLenum target, GLuint id )
{
    struct glBeginQueryARB_params args = { .teb = NtCurrentTeb(), .target = target, .id = id };
    NTSTATUS status;
    TRACE( "target %d, id %d\n", target, id );
    if ((status = UNIX_CALL( glBeginQueryARB, &args ))) WARN( "glBeginQueryARB returned %#lx\n", status );
}

static void WINAPI glBeginQueryIndexed( GLenum target, GLuint index, GLuint id )
{
    struct glBeginQueryIndexed_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .id = id };
    NTSTATUS status;
    TRACE( "target %d, index %d, id %d\n", target, index, id );
    if ((status = UNIX_CALL( glBeginQueryIndexed, &args ))) WARN( "glBeginQueryIndexed returned %#lx\n", status );
}

static void WINAPI glBeginTransformFeedback( GLenum primitiveMode )
{
    struct glBeginTransformFeedback_params args = { .teb = NtCurrentTeb(), .primitiveMode = primitiveMode };
    NTSTATUS status;
    TRACE( "primitiveMode %d\n", primitiveMode );
    if ((status = UNIX_CALL( glBeginTransformFeedback, &args ))) WARN( "glBeginTransformFeedback returned %#lx\n", status );
}

static void WINAPI glBeginTransformFeedbackEXT( GLenum primitiveMode )
{
    struct glBeginTransformFeedbackEXT_params args = { .teb = NtCurrentTeb(), .primitiveMode = primitiveMode };
    NTSTATUS status;
    TRACE( "primitiveMode %d\n", primitiveMode );
    if ((status = UNIX_CALL( glBeginTransformFeedbackEXT, &args ))) WARN( "glBeginTransformFeedbackEXT returned %#lx\n", status );
}

static void WINAPI glBeginTransformFeedbackNV( GLenum primitiveMode )
{
    struct glBeginTransformFeedbackNV_params args = { .teb = NtCurrentTeb(), .primitiveMode = primitiveMode };
    NTSTATUS status;
    TRACE( "primitiveMode %d\n", primitiveMode );
    if ((status = UNIX_CALL( glBeginTransformFeedbackNV, &args ))) WARN( "glBeginTransformFeedbackNV returned %#lx\n", status );
}

static void WINAPI glBeginVertexShaderEXT(void)
{
    struct glBeginVertexShaderEXT_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glBeginVertexShaderEXT, &args ))) WARN( "glBeginVertexShaderEXT returned %#lx\n", status );
}

static void WINAPI glBeginVideoCaptureNV( GLuint video_capture_slot )
{
    struct glBeginVideoCaptureNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot };
    NTSTATUS status;
    TRACE( "video_capture_slot %d\n", video_capture_slot );
    if ((status = UNIX_CALL( glBeginVideoCaptureNV, &args ))) WARN( "glBeginVideoCaptureNV returned %#lx\n", status );
}

static void WINAPI glBindAttribLocation( GLuint program, GLuint index, const GLchar *name )
{
    struct glBindAttribLocation_params args = { .teb = NtCurrentTeb(), .program = program, .index = index, .name = name };
    NTSTATUS status;
    TRACE( "program %d, index %d, name %p\n", program, index, name );
    if ((status = UNIX_CALL( glBindAttribLocation, &args ))) WARN( "glBindAttribLocation returned %#lx\n", status );
}

static void WINAPI glBindAttribLocationARB( GLhandleARB programObj, GLuint index, const GLcharARB *name )
{
    struct glBindAttribLocationARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj, .index = index, .name = name };
    NTSTATUS status;
    TRACE( "programObj %d, index %d, name %p\n", programObj, index, name );
    if ((status = UNIX_CALL( glBindAttribLocationARB, &args ))) WARN( "glBindAttribLocationARB returned %#lx\n", status );
}

static void WINAPI glBindBuffer( GLenum target, GLuint buffer )
{
    struct glBindBuffer_params args = { .teb = NtCurrentTeb(), .target = target, .buffer = buffer };
    NTSTATUS status;
    TRACE( "target %d, buffer %d\n", target, buffer );
    if ((status = UNIX_CALL( glBindBuffer, &args ))) WARN( "glBindBuffer returned %#lx\n", status );
}

static void WINAPI glBindBufferARB( GLenum target, GLuint buffer )
{
    struct glBindBufferARB_params args = { .teb = NtCurrentTeb(), .target = target, .buffer = buffer };
    NTSTATUS status;
    TRACE( "target %d, buffer %d\n", target, buffer );
    if ((status = UNIX_CALL( glBindBufferARB, &args ))) WARN( "glBindBufferARB returned %#lx\n", status );
}

static void WINAPI glBindBufferBase( GLenum target, GLuint index, GLuint buffer )
{
    struct glBindBufferBase_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .buffer = buffer };
    NTSTATUS status;
    TRACE( "target %d, index %d, buffer %d\n", target, index, buffer );
    if ((status = UNIX_CALL( glBindBufferBase, &args ))) WARN( "glBindBufferBase returned %#lx\n", status );
}

static void WINAPI glBindBufferBaseEXT( GLenum target, GLuint index, GLuint buffer )
{
    struct glBindBufferBaseEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .buffer = buffer };
    NTSTATUS status;
    TRACE( "target %d, index %d, buffer %d\n", target, index, buffer );
    if ((status = UNIX_CALL( glBindBufferBaseEXT, &args ))) WARN( "glBindBufferBaseEXT returned %#lx\n", status );
}

static void WINAPI glBindBufferBaseNV( GLenum target, GLuint index, GLuint buffer )
{
    struct glBindBufferBaseNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .buffer = buffer };
    NTSTATUS status;
    TRACE( "target %d, index %d, buffer %d\n", target, index, buffer );
    if ((status = UNIX_CALL( glBindBufferBaseNV, &args ))) WARN( "glBindBufferBaseNV returned %#lx\n", status );
}

static void WINAPI glBindBufferOffsetEXT( GLenum target, GLuint index, GLuint buffer, GLintptr offset )
{
    struct glBindBufferOffsetEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .buffer = buffer, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, index %d, buffer %d, offset %Id\n", target, index, buffer, offset );
    if ((status = UNIX_CALL( glBindBufferOffsetEXT, &args ))) WARN( "glBindBufferOffsetEXT returned %#lx\n", status );
}

static void WINAPI glBindBufferOffsetNV( GLenum target, GLuint index, GLuint buffer, GLintptr offset )
{
    struct glBindBufferOffsetNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .buffer = buffer, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, index %d, buffer %d, offset %Id\n", target, index, buffer, offset );
    if ((status = UNIX_CALL( glBindBufferOffsetNV, &args ))) WARN( "glBindBufferOffsetNV returned %#lx\n", status );
}

static void WINAPI glBindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
    struct glBindBufferRange_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .buffer = buffer, .offset = offset, .size = size };
    NTSTATUS status;
    TRACE( "target %d, index %d, buffer %d, offset %Id, size %Id\n", target, index, buffer, offset, size );
    if ((status = UNIX_CALL( glBindBufferRange, &args ))) WARN( "glBindBufferRange returned %#lx\n", status );
}

static void WINAPI glBindBufferRangeEXT( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
    struct glBindBufferRangeEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .buffer = buffer, .offset = offset, .size = size };
    NTSTATUS status;
    TRACE( "target %d, index %d, buffer %d, offset %Id, size %Id\n", target, index, buffer, offset, size );
    if ((status = UNIX_CALL( glBindBufferRangeEXT, &args ))) WARN( "glBindBufferRangeEXT returned %#lx\n", status );
}

static void WINAPI glBindBufferRangeNV( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
    struct glBindBufferRangeNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .buffer = buffer, .offset = offset, .size = size };
    NTSTATUS status;
    TRACE( "target %d, index %d, buffer %d, offset %Id, size %Id\n", target, index, buffer, offset, size );
    if ((status = UNIX_CALL( glBindBufferRangeNV, &args ))) WARN( "glBindBufferRangeNV returned %#lx\n", status );
}

static void WINAPI glBindBuffersBase( GLenum target, GLuint first, GLsizei count, const GLuint *buffers )
{
    struct glBindBuffersBase_params args = { .teb = NtCurrentTeb(), .target = target, .first = first, .count = count, .buffers = buffers };
    NTSTATUS status;
    TRACE( "target %d, first %d, count %d, buffers %p\n", target, first, count, buffers );
    if ((status = UNIX_CALL( glBindBuffersBase, &args ))) WARN( "glBindBuffersBase returned %#lx\n", status );
}

static void WINAPI glBindBuffersRange( GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes )
{
    struct glBindBuffersRange_params args = { .teb = NtCurrentTeb(), .target = target, .first = first, .count = count, .buffers = buffers, .offsets = offsets, .sizes = sizes };
    NTSTATUS status;
    TRACE( "target %d, first %d, count %d, buffers %p, offsets %p, sizes %p\n", target, first, count, buffers, offsets, sizes );
    if ((status = UNIX_CALL( glBindBuffersRange, &args ))) WARN( "glBindBuffersRange returned %#lx\n", status );
}

static void WINAPI glBindFragDataLocation( GLuint program, GLuint color, const GLchar *name )
{
    struct glBindFragDataLocation_params args = { .teb = NtCurrentTeb(), .program = program, .color = color, .name = name };
    NTSTATUS status;
    TRACE( "program %d, color %d, name %p\n", program, color, name );
    if ((status = UNIX_CALL( glBindFragDataLocation, &args ))) WARN( "glBindFragDataLocation returned %#lx\n", status );
}

static void WINAPI glBindFragDataLocationEXT( GLuint program, GLuint color, const GLchar *name )
{
    struct glBindFragDataLocationEXT_params args = { .teb = NtCurrentTeb(), .program = program, .color = color, .name = name };
    NTSTATUS status;
    TRACE( "program %d, color %d, name %p\n", program, color, name );
    if ((status = UNIX_CALL( glBindFragDataLocationEXT, &args ))) WARN( "glBindFragDataLocationEXT returned %#lx\n", status );
}

static void WINAPI glBindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, const GLchar *name )
{
    struct glBindFragDataLocationIndexed_params args = { .teb = NtCurrentTeb(), .program = program, .colorNumber = colorNumber, .index = index, .name = name };
    NTSTATUS status;
    TRACE( "program %d, colorNumber %d, index %d, name %p\n", program, colorNumber, index, name );
    if ((status = UNIX_CALL( glBindFragDataLocationIndexed, &args ))) WARN( "glBindFragDataLocationIndexed returned %#lx\n", status );
}

static void WINAPI glBindFragmentShaderATI( GLuint id )
{
    struct glBindFragmentShaderATI_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glBindFragmentShaderATI, &args ))) WARN( "glBindFragmentShaderATI returned %#lx\n", status );
}

static void WINAPI glBindFramebuffer( GLenum target, GLuint framebuffer )
{
    struct glBindFramebuffer_params args = { .teb = NtCurrentTeb(), .target = target, .framebuffer = framebuffer };
    NTSTATUS status;
    TRACE( "target %d, framebuffer %d\n", target, framebuffer );
    if ((status = UNIX_CALL( glBindFramebuffer, &args ))) WARN( "glBindFramebuffer returned %#lx\n", status );
}

static void WINAPI glBindFramebufferEXT( GLenum target, GLuint framebuffer )
{
    struct glBindFramebufferEXT_params args = { .teb = NtCurrentTeb(), .target = target, .framebuffer = framebuffer };
    NTSTATUS status;
    TRACE( "target %d, framebuffer %d\n", target, framebuffer );
    if ((status = UNIX_CALL( glBindFramebufferEXT, &args ))) WARN( "glBindFramebufferEXT returned %#lx\n", status );
}

static void WINAPI glBindImageTexture( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format )
{
    struct glBindImageTexture_params args = { .teb = NtCurrentTeb(), .unit = unit, .texture = texture, .level = level, .layered = layered, .layer = layer, .access = access, .format = format };
    NTSTATUS status;
    TRACE( "unit %d, texture %d, level %d, layered %d, layer %d, access %d, format %d\n", unit, texture, level, layered, layer, access, format );
    if ((status = UNIX_CALL( glBindImageTexture, &args ))) WARN( "glBindImageTexture returned %#lx\n", status );
}

static void WINAPI glBindImageTextureEXT( GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format )
{
    struct glBindImageTextureEXT_params args = { .teb = NtCurrentTeb(), .index = index, .texture = texture, .level = level, .layered = layered, .layer = layer, .access = access, .format = format };
    NTSTATUS status;
    TRACE( "index %d, texture %d, level %d, layered %d, layer %d, access %d, format %d\n", index, texture, level, layered, layer, access, format );
    if ((status = UNIX_CALL( glBindImageTextureEXT, &args ))) WARN( "glBindImageTextureEXT returned %#lx\n", status );
}

static void WINAPI glBindImageTextures( GLuint first, GLsizei count, const GLuint *textures )
{
    struct glBindImageTextures_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .textures = textures };
    NTSTATUS status;
    TRACE( "first %d, count %d, textures %p\n", first, count, textures );
    if ((status = UNIX_CALL( glBindImageTextures, &args ))) WARN( "glBindImageTextures returned %#lx\n", status );
}

static GLuint WINAPI glBindLightParameterEXT( GLenum light, GLenum value )
{
    struct glBindLightParameterEXT_params args = { .teb = NtCurrentTeb(), .light = light, .value = value };
    NTSTATUS status;
    TRACE( "light %d, value %d\n", light, value );
    if ((status = UNIX_CALL( glBindLightParameterEXT, &args ))) WARN( "glBindLightParameterEXT returned %#lx\n", status );
    return args.ret;
}

static GLuint WINAPI glBindMaterialParameterEXT( GLenum face, GLenum value )
{
    struct glBindMaterialParameterEXT_params args = { .teb = NtCurrentTeb(), .face = face, .value = value };
    NTSTATUS status;
    TRACE( "face %d, value %d\n", face, value );
    if ((status = UNIX_CALL( glBindMaterialParameterEXT, &args ))) WARN( "glBindMaterialParameterEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glBindMultiTextureEXT( GLenum texunit, GLenum target, GLuint texture )
{
    struct glBindMultiTextureEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .texture = texture };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, texture %d\n", texunit, target, texture );
    if ((status = UNIX_CALL( glBindMultiTextureEXT, &args ))) WARN( "glBindMultiTextureEXT returned %#lx\n", status );
}

static GLuint WINAPI glBindParameterEXT( GLenum value )
{
    struct glBindParameterEXT_params args = { .teb = NtCurrentTeb(), .value = value };
    NTSTATUS status;
    TRACE( "value %d\n", value );
    if ((status = UNIX_CALL( glBindParameterEXT, &args ))) WARN( "glBindParameterEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glBindProgramARB( GLenum target, GLuint program )
{
    struct glBindProgramARB_params args = { .teb = NtCurrentTeb(), .target = target, .program = program };
    NTSTATUS status;
    TRACE( "target %d, program %d\n", target, program );
    if ((status = UNIX_CALL( glBindProgramARB, &args ))) WARN( "glBindProgramARB returned %#lx\n", status );
}

static void WINAPI glBindProgramNV( GLenum target, GLuint id )
{
    struct glBindProgramNV_params args = { .teb = NtCurrentTeb(), .target = target, .id = id };
    NTSTATUS status;
    TRACE( "target %d, id %d\n", target, id );
    if ((status = UNIX_CALL( glBindProgramNV, &args ))) WARN( "glBindProgramNV returned %#lx\n", status );
}

static void WINAPI glBindProgramPipeline( GLuint pipeline )
{
    struct glBindProgramPipeline_params args = { .teb = NtCurrentTeb(), .pipeline = pipeline };
    NTSTATUS status;
    TRACE( "pipeline %d\n", pipeline );
    if ((status = UNIX_CALL( glBindProgramPipeline, &args ))) WARN( "glBindProgramPipeline returned %#lx\n", status );
}

static void WINAPI glBindRenderbuffer( GLenum target, GLuint renderbuffer )
{
    struct glBindRenderbuffer_params args = { .teb = NtCurrentTeb(), .target = target, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "target %d, renderbuffer %d\n", target, renderbuffer );
    if ((status = UNIX_CALL( glBindRenderbuffer, &args ))) WARN( "glBindRenderbuffer returned %#lx\n", status );
}

static void WINAPI glBindRenderbufferEXT( GLenum target, GLuint renderbuffer )
{
    struct glBindRenderbufferEXT_params args = { .teb = NtCurrentTeb(), .target = target, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "target %d, renderbuffer %d\n", target, renderbuffer );
    if ((status = UNIX_CALL( glBindRenderbufferEXT, &args ))) WARN( "glBindRenderbufferEXT returned %#lx\n", status );
}

static void WINAPI glBindSampler( GLuint unit, GLuint sampler )
{
    struct glBindSampler_params args = { .teb = NtCurrentTeb(), .unit = unit, .sampler = sampler };
    NTSTATUS status;
    TRACE( "unit %d, sampler %d\n", unit, sampler );
    if ((status = UNIX_CALL( glBindSampler, &args ))) WARN( "glBindSampler returned %#lx\n", status );
}

static void WINAPI glBindSamplers( GLuint first, GLsizei count, const GLuint *samplers )
{
    struct glBindSamplers_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .samplers = samplers };
    NTSTATUS status;
    TRACE( "first %d, count %d, samplers %p\n", first, count, samplers );
    if ((status = UNIX_CALL( glBindSamplers, &args ))) WARN( "glBindSamplers returned %#lx\n", status );
}

static void WINAPI glBindShadingRateImageNV( GLuint texture )
{
    struct glBindShadingRateImageNV_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glBindShadingRateImageNV, &args ))) WARN( "glBindShadingRateImageNV returned %#lx\n", status );
}

static GLuint WINAPI glBindTexGenParameterEXT( GLenum unit, GLenum coord, GLenum value )
{
    struct glBindTexGenParameterEXT_params args = { .teb = NtCurrentTeb(), .unit = unit, .coord = coord, .value = value };
    NTSTATUS status;
    TRACE( "unit %d, coord %d, value %d\n", unit, coord, value );
    if ((status = UNIX_CALL( glBindTexGenParameterEXT, &args ))) WARN( "glBindTexGenParameterEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glBindTextureEXT( GLenum target, GLuint texture )
{
    struct glBindTextureEXT_params args = { .teb = NtCurrentTeb(), .target = target, .texture = texture };
    NTSTATUS status;
    TRACE( "target %d, texture %d\n", target, texture );
    if ((status = UNIX_CALL( glBindTextureEXT, &args ))) WARN( "glBindTextureEXT returned %#lx\n", status );
}

static void WINAPI glBindTextureUnit( GLuint unit, GLuint texture )
{
    struct glBindTextureUnit_params args = { .teb = NtCurrentTeb(), .unit = unit, .texture = texture };
    NTSTATUS status;
    TRACE( "unit %d, texture %d\n", unit, texture );
    if ((status = UNIX_CALL( glBindTextureUnit, &args ))) WARN( "glBindTextureUnit returned %#lx\n", status );
}

static GLuint WINAPI glBindTextureUnitParameterEXT( GLenum unit, GLenum value )
{
    struct glBindTextureUnitParameterEXT_params args = { .teb = NtCurrentTeb(), .unit = unit, .value = value };
    NTSTATUS status;
    TRACE( "unit %d, value %d\n", unit, value );
    if ((status = UNIX_CALL( glBindTextureUnitParameterEXT, &args ))) WARN( "glBindTextureUnitParameterEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glBindTextures( GLuint first, GLsizei count, const GLuint *textures )
{
    struct glBindTextures_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .textures = textures };
    NTSTATUS status;
    TRACE( "first %d, count %d, textures %p\n", first, count, textures );
    if ((status = UNIX_CALL( glBindTextures, &args ))) WARN( "glBindTextures returned %#lx\n", status );
}

static void WINAPI glBindTransformFeedback( GLenum target, GLuint id )
{
    struct glBindTransformFeedback_params args = { .teb = NtCurrentTeb(), .target = target, .id = id };
    NTSTATUS status;
    TRACE( "target %d, id %d\n", target, id );
    if ((status = UNIX_CALL( glBindTransformFeedback, &args ))) WARN( "glBindTransformFeedback returned %#lx\n", status );
}

static void WINAPI glBindTransformFeedbackNV( GLenum target, GLuint id )
{
    struct glBindTransformFeedbackNV_params args = { .teb = NtCurrentTeb(), .target = target, .id = id };
    NTSTATUS status;
    TRACE( "target %d, id %d\n", target, id );
    if ((status = UNIX_CALL( glBindTransformFeedbackNV, &args ))) WARN( "glBindTransformFeedbackNV returned %#lx\n", status );
}

static void WINAPI glBindVertexArray( GLuint array )
{
    struct glBindVertexArray_params args = { .teb = NtCurrentTeb(), .array = array };
    NTSTATUS status;
    TRACE( "array %d\n", array );
    if ((status = UNIX_CALL( glBindVertexArray, &args ))) WARN( "glBindVertexArray returned %#lx\n", status );
}

static void WINAPI glBindVertexArrayAPPLE( GLuint array )
{
    struct glBindVertexArrayAPPLE_params args = { .teb = NtCurrentTeb(), .array = array };
    NTSTATUS status;
    TRACE( "array %d\n", array );
    if ((status = UNIX_CALL( glBindVertexArrayAPPLE, &args ))) WARN( "glBindVertexArrayAPPLE returned %#lx\n", status );
}

static void WINAPI glBindVertexBuffer( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride )
{
    struct glBindVertexBuffer_params args = { .teb = NtCurrentTeb(), .bindingindex = bindingindex, .buffer = buffer, .offset = offset, .stride = stride };
    NTSTATUS status;
    TRACE( "bindingindex %d, buffer %d, offset %Id, stride %d\n", bindingindex, buffer, offset, stride );
    if ((status = UNIX_CALL( glBindVertexBuffer, &args ))) WARN( "glBindVertexBuffer returned %#lx\n", status );
}

static void WINAPI glBindVertexBuffers( GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides )
{
    struct glBindVertexBuffers_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .buffers = buffers, .offsets = offsets, .strides = strides };
    NTSTATUS status;
    TRACE( "first %d, count %d, buffers %p, offsets %p, strides %p\n", first, count, buffers, offsets, strides );
    if ((status = UNIX_CALL( glBindVertexBuffers, &args ))) WARN( "glBindVertexBuffers returned %#lx\n", status );
}

static void WINAPI glBindVertexShaderEXT( GLuint id )
{
    struct glBindVertexShaderEXT_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glBindVertexShaderEXT, &args ))) WARN( "glBindVertexShaderEXT returned %#lx\n", status );
}

static void WINAPI glBindVideoCaptureStreamBufferNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset )
{
    struct glBindVideoCaptureStreamBufferNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .stream = stream, .frame_region = frame_region, .offset = offset };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, stream %d, frame_region %d, offset %Id\n", video_capture_slot, stream, frame_region, offset );
    if ((status = UNIX_CALL( glBindVideoCaptureStreamBufferNV, &args ))) WARN( "glBindVideoCaptureStreamBufferNV returned %#lx\n", status );
}

static void WINAPI glBindVideoCaptureStreamTextureNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture )
{
    struct glBindVideoCaptureStreamTextureNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .stream = stream, .frame_region = frame_region, .target = target, .texture = texture };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, stream %d, frame_region %d, target %d, texture %d\n", video_capture_slot, stream, frame_region, target, texture );
    if ((status = UNIX_CALL( glBindVideoCaptureStreamTextureNV, &args ))) WARN( "glBindVideoCaptureStreamTextureNV returned %#lx\n", status );
}

static void WINAPI glBinormal3bEXT( GLbyte bx, GLbyte by, GLbyte bz )
{
    struct glBinormal3bEXT_params args = { .teb = NtCurrentTeb(), .bx = bx, .by = by, .bz = bz };
    NTSTATUS status;
    TRACE( "bx %d, by %d, bz %d\n", bx, by, bz );
    if ((status = UNIX_CALL( glBinormal3bEXT, &args ))) WARN( "glBinormal3bEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3bvEXT( const GLbyte *v )
{
    struct glBinormal3bvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glBinormal3bvEXT, &args ))) WARN( "glBinormal3bvEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3dEXT( GLdouble bx, GLdouble by, GLdouble bz )
{
    struct glBinormal3dEXT_params args = { .teb = NtCurrentTeb(), .bx = bx, .by = by, .bz = bz };
    NTSTATUS status;
    TRACE( "bx %f, by %f, bz %f\n", bx, by, bz );
    if ((status = UNIX_CALL( glBinormal3dEXT, &args ))) WARN( "glBinormal3dEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3dvEXT( const GLdouble *v )
{
    struct glBinormal3dvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glBinormal3dvEXT, &args ))) WARN( "glBinormal3dvEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3fEXT( GLfloat bx, GLfloat by, GLfloat bz )
{
    struct glBinormal3fEXT_params args = { .teb = NtCurrentTeb(), .bx = bx, .by = by, .bz = bz };
    NTSTATUS status;
    TRACE( "bx %f, by %f, bz %f\n", bx, by, bz );
    if ((status = UNIX_CALL( glBinormal3fEXT, &args ))) WARN( "glBinormal3fEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3fvEXT( const GLfloat *v )
{
    struct glBinormal3fvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glBinormal3fvEXT, &args ))) WARN( "glBinormal3fvEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3iEXT( GLint bx, GLint by, GLint bz )
{
    struct glBinormal3iEXT_params args = { .teb = NtCurrentTeb(), .bx = bx, .by = by, .bz = bz };
    NTSTATUS status;
    TRACE( "bx %d, by %d, bz %d\n", bx, by, bz );
    if ((status = UNIX_CALL( glBinormal3iEXT, &args ))) WARN( "glBinormal3iEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3ivEXT( const GLint *v )
{
    struct glBinormal3ivEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glBinormal3ivEXT, &args ))) WARN( "glBinormal3ivEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3sEXT( GLshort bx, GLshort by, GLshort bz )
{
    struct glBinormal3sEXT_params args = { .teb = NtCurrentTeb(), .bx = bx, .by = by, .bz = bz };
    NTSTATUS status;
    TRACE( "bx %d, by %d, bz %d\n", bx, by, bz );
    if ((status = UNIX_CALL( glBinormal3sEXT, &args ))) WARN( "glBinormal3sEXT returned %#lx\n", status );
}

static void WINAPI glBinormal3svEXT( const GLshort *v )
{
    struct glBinormal3svEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glBinormal3svEXT, &args ))) WARN( "glBinormal3svEXT returned %#lx\n", status );
}

static void WINAPI glBinormalPointerEXT( GLenum type, GLsizei stride, const void *pointer )
{
    struct glBinormalPointerEXT_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
    if ((status = UNIX_CALL( glBinormalPointerEXT, &args ))) WARN( "glBinormalPointerEXT returned %#lx\n", status );
}

static void WINAPI glBitmapxOES( GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte *bitmap )
{
    struct glBitmapxOES_params args = { .teb = NtCurrentTeb(), .width = width, .height = height, .xorig = xorig, .yorig = yorig, .xmove = xmove, .ymove = ymove, .bitmap = bitmap };
    NTSTATUS status;
    TRACE( "width %d, height %d, xorig %d, yorig %d, xmove %d, ymove %d, bitmap %p\n", width, height, xorig, yorig, xmove, ymove, bitmap );
    if ((status = UNIX_CALL( glBitmapxOES, &args ))) WARN( "glBitmapxOES returned %#lx\n", status );
}

static void WINAPI glBlendBarrierKHR(void)
{
    struct glBlendBarrierKHR_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glBlendBarrierKHR, &args ))) WARN( "glBlendBarrierKHR returned %#lx\n", status );
}

static void WINAPI glBlendBarrierNV(void)
{
    struct glBlendBarrierNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glBlendBarrierNV, &args ))) WARN( "glBlendBarrierNV returned %#lx\n", status );
}

static void WINAPI glBlendColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
    struct glBlendColor_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glBlendColor, &args ))) WARN( "glBlendColor returned %#lx\n", status );
}

static void WINAPI glBlendColorEXT( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
    struct glBlendColorEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glBlendColorEXT, &args ))) WARN( "glBlendColorEXT returned %#lx\n", status );
}

static void WINAPI glBlendColorxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha )
{
    struct glBlendColorxOES_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glBlendColorxOES, &args ))) WARN( "glBlendColorxOES returned %#lx\n", status );
}

static void WINAPI glBlendEquation( GLenum mode )
{
    struct glBlendEquation_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glBlendEquation, &args ))) WARN( "glBlendEquation returned %#lx\n", status );
}

static void WINAPI glBlendEquationEXT( GLenum mode )
{
    struct glBlendEquationEXT_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glBlendEquationEXT, &args ))) WARN( "glBlendEquationEXT returned %#lx\n", status );
}

static void WINAPI glBlendEquationIndexedAMD( GLuint buf, GLenum mode )
{
    struct glBlendEquationIndexedAMD_params args = { .teb = NtCurrentTeb(), .buf = buf, .mode = mode };
    NTSTATUS status;
    TRACE( "buf %d, mode %d\n", buf, mode );
    if ((status = UNIX_CALL( glBlendEquationIndexedAMD, &args ))) WARN( "glBlendEquationIndexedAMD returned %#lx\n", status );
}

static void WINAPI glBlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha )
{
    struct glBlendEquationSeparate_params args = { .teb = NtCurrentTeb(), .modeRGB = modeRGB, .modeAlpha = modeAlpha };
    NTSTATUS status;
    TRACE( "modeRGB %d, modeAlpha %d\n", modeRGB, modeAlpha );
    if ((status = UNIX_CALL( glBlendEquationSeparate, &args ))) WARN( "glBlendEquationSeparate returned %#lx\n", status );
}

static void WINAPI glBlendEquationSeparateEXT( GLenum modeRGB, GLenum modeAlpha )
{
    struct glBlendEquationSeparateEXT_params args = { .teb = NtCurrentTeb(), .modeRGB = modeRGB, .modeAlpha = modeAlpha };
    NTSTATUS status;
    TRACE( "modeRGB %d, modeAlpha %d\n", modeRGB, modeAlpha );
    if ((status = UNIX_CALL( glBlendEquationSeparateEXT, &args ))) WARN( "glBlendEquationSeparateEXT returned %#lx\n", status );
}

static void WINAPI glBlendEquationSeparateIndexedAMD( GLuint buf, GLenum modeRGB, GLenum modeAlpha )
{
    struct glBlendEquationSeparateIndexedAMD_params args = { .teb = NtCurrentTeb(), .buf = buf, .modeRGB = modeRGB, .modeAlpha = modeAlpha };
    NTSTATUS status;
    TRACE( "buf %d, modeRGB %d, modeAlpha %d\n", buf, modeRGB, modeAlpha );
    if ((status = UNIX_CALL( glBlendEquationSeparateIndexedAMD, &args ))) WARN( "glBlendEquationSeparateIndexedAMD returned %#lx\n", status );
}

static void WINAPI glBlendEquationSeparatei( GLuint buf, GLenum modeRGB, GLenum modeAlpha )
{
    struct glBlendEquationSeparatei_params args = { .teb = NtCurrentTeb(), .buf = buf, .modeRGB = modeRGB, .modeAlpha = modeAlpha };
    NTSTATUS status;
    TRACE( "buf %d, modeRGB %d, modeAlpha %d\n", buf, modeRGB, modeAlpha );
    if ((status = UNIX_CALL( glBlendEquationSeparatei, &args ))) WARN( "glBlendEquationSeparatei returned %#lx\n", status );
}

static void WINAPI glBlendEquationSeparateiARB( GLuint buf, GLenum modeRGB, GLenum modeAlpha )
{
    struct glBlendEquationSeparateiARB_params args = { .teb = NtCurrentTeb(), .buf = buf, .modeRGB = modeRGB, .modeAlpha = modeAlpha };
    NTSTATUS status;
    TRACE( "buf %d, modeRGB %d, modeAlpha %d\n", buf, modeRGB, modeAlpha );
    if ((status = UNIX_CALL( glBlendEquationSeparateiARB, &args ))) WARN( "glBlendEquationSeparateiARB returned %#lx\n", status );
}

static void WINAPI glBlendEquationi( GLuint buf, GLenum mode )
{
    struct glBlendEquationi_params args = { .teb = NtCurrentTeb(), .buf = buf, .mode = mode };
    NTSTATUS status;
    TRACE( "buf %d, mode %d\n", buf, mode );
    if ((status = UNIX_CALL( glBlendEquationi, &args ))) WARN( "glBlendEquationi returned %#lx\n", status );
}

static void WINAPI glBlendEquationiARB( GLuint buf, GLenum mode )
{
    struct glBlendEquationiARB_params args = { .teb = NtCurrentTeb(), .buf = buf, .mode = mode };
    NTSTATUS status;
    TRACE( "buf %d, mode %d\n", buf, mode );
    if ((status = UNIX_CALL( glBlendEquationiARB, &args ))) WARN( "glBlendEquationiARB returned %#lx\n", status );
}

static void WINAPI glBlendFuncIndexedAMD( GLuint buf, GLenum src, GLenum dst )
{
    struct glBlendFuncIndexedAMD_params args = { .teb = NtCurrentTeb(), .buf = buf, .src = src, .dst = dst };
    NTSTATUS status;
    TRACE( "buf %d, src %d, dst %d\n", buf, src, dst );
    if ((status = UNIX_CALL( glBlendFuncIndexedAMD, &args ))) WARN( "glBlendFuncIndexedAMD returned %#lx\n", status );
}

static void WINAPI glBlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
{
    struct glBlendFuncSeparate_params args = { .teb = NtCurrentTeb(), .sfactorRGB = sfactorRGB, .dfactorRGB = dfactorRGB, .sfactorAlpha = sfactorAlpha, .dfactorAlpha = dfactorAlpha };
    NTSTATUS status;
    TRACE( "sfactorRGB %d, dfactorRGB %d, sfactorAlpha %d, dfactorAlpha %d\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
    if ((status = UNIX_CALL( glBlendFuncSeparate, &args ))) WARN( "glBlendFuncSeparate returned %#lx\n", status );
}

static void WINAPI glBlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
{
    struct glBlendFuncSeparateEXT_params args = { .teb = NtCurrentTeb(), .sfactorRGB = sfactorRGB, .dfactorRGB = dfactorRGB, .sfactorAlpha = sfactorAlpha, .dfactorAlpha = dfactorAlpha };
    NTSTATUS status;
    TRACE( "sfactorRGB %d, dfactorRGB %d, sfactorAlpha %d, dfactorAlpha %d\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
    if ((status = UNIX_CALL( glBlendFuncSeparateEXT, &args ))) WARN( "glBlendFuncSeparateEXT returned %#lx\n", status );
}

static void WINAPI glBlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
{
    struct glBlendFuncSeparateINGR_params args = { .teb = NtCurrentTeb(), .sfactorRGB = sfactorRGB, .dfactorRGB = dfactorRGB, .sfactorAlpha = sfactorAlpha, .dfactorAlpha = dfactorAlpha };
    NTSTATUS status;
    TRACE( "sfactorRGB %d, dfactorRGB %d, sfactorAlpha %d, dfactorAlpha %d\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
    if ((status = UNIX_CALL( glBlendFuncSeparateINGR, &args ))) WARN( "glBlendFuncSeparateINGR returned %#lx\n", status );
}

static void WINAPI glBlendFuncSeparateIndexedAMD( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
{
    struct glBlendFuncSeparateIndexedAMD_params args = { .teb = NtCurrentTeb(), .buf = buf, .srcRGB = srcRGB, .dstRGB = dstRGB, .srcAlpha = srcAlpha, .dstAlpha = dstAlpha };
    NTSTATUS status;
    TRACE( "buf %d, srcRGB %d, dstRGB %d, srcAlpha %d, dstAlpha %d\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
    if ((status = UNIX_CALL( glBlendFuncSeparateIndexedAMD, &args ))) WARN( "glBlendFuncSeparateIndexedAMD returned %#lx\n", status );
}

static void WINAPI glBlendFuncSeparatei( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
{
    struct glBlendFuncSeparatei_params args = { .teb = NtCurrentTeb(), .buf = buf, .srcRGB = srcRGB, .dstRGB = dstRGB, .srcAlpha = srcAlpha, .dstAlpha = dstAlpha };
    NTSTATUS status;
    TRACE( "buf %d, srcRGB %d, dstRGB %d, srcAlpha %d, dstAlpha %d\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
    if ((status = UNIX_CALL( glBlendFuncSeparatei, &args ))) WARN( "glBlendFuncSeparatei returned %#lx\n", status );
}

static void WINAPI glBlendFuncSeparateiARB( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
{
    struct glBlendFuncSeparateiARB_params args = { .teb = NtCurrentTeb(), .buf = buf, .srcRGB = srcRGB, .dstRGB = dstRGB, .srcAlpha = srcAlpha, .dstAlpha = dstAlpha };
    NTSTATUS status;
    TRACE( "buf %d, srcRGB %d, dstRGB %d, srcAlpha %d, dstAlpha %d\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
    if ((status = UNIX_CALL( glBlendFuncSeparateiARB, &args ))) WARN( "glBlendFuncSeparateiARB returned %#lx\n", status );
}

static void WINAPI glBlendFunci( GLuint buf, GLenum src, GLenum dst )
{
    struct glBlendFunci_params args = { .teb = NtCurrentTeb(), .buf = buf, .src = src, .dst = dst };
    NTSTATUS status;
    TRACE( "buf %d, src %d, dst %d\n", buf, src, dst );
    if ((status = UNIX_CALL( glBlendFunci, &args ))) WARN( "glBlendFunci returned %#lx\n", status );
}

static void WINAPI glBlendFunciARB( GLuint buf, GLenum src, GLenum dst )
{
    struct glBlendFunciARB_params args = { .teb = NtCurrentTeb(), .buf = buf, .src = src, .dst = dst };
    NTSTATUS status;
    TRACE( "buf %d, src %d, dst %d\n", buf, src, dst );
    if ((status = UNIX_CALL( glBlendFunciARB, &args ))) WARN( "glBlendFunciARB returned %#lx\n", status );
}

static void WINAPI glBlendParameteriNV( GLenum pname, GLint value )
{
    struct glBlendParameteriNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "pname %d, value %d\n", pname, value );
    if ((status = UNIX_CALL( glBlendParameteriNV, &args ))) WARN( "glBlendParameteriNV returned %#lx\n", status );
}

static void WINAPI glBlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
{
    struct glBlitFramebuffer_params args = { .teb = NtCurrentTeb(), .srcX0 = srcX0, .srcY0 = srcY0, .srcX1 = srcX1, .srcY1 = srcY1, .dstX0 = dstX0, .dstY0 = dstY0, .dstX1 = dstX1, .dstY1 = dstY1, .mask = mask, .filter = filter };
    NTSTATUS status;
    TRACE( "srcX0 %d, srcY0 %d, srcX1 %d, srcY1 %d, dstX0 %d, dstY0 %d, dstX1 %d, dstY1 %d, mask %d, filter %d\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
    if ((status = UNIX_CALL( glBlitFramebuffer, &args ))) WARN( "glBlitFramebuffer returned %#lx\n", status );
}

static void WINAPI glBlitFramebufferEXT( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
{
    struct glBlitFramebufferEXT_params args = { .teb = NtCurrentTeb(), .srcX0 = srcX0, .srcY0 = srcY0, .srcX1 = srcX1, .srcY1 = srcY1, .dstX0 = dstX0, .dstY0 = dstY0, .dstX1 = dstX1, .dstY1 = dstY1, .mask = mask, .filter = filter };
    NTSTATUS status;
    TRACE( "srcX0 %d, srcY0 %d, srcX1 %d, srcY1 %d, dstX0 %d, dstY0 %d, dstX1 %d, dstY1 %d, mask %d, filter %d\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
    if ((status = UNIX_CALL( glBlitFramebufferEXT, &args ))) WARN( "glBlitFramebufferEXT returned %#lx\n", status );
}

static void WINAPI glBlitNamedFramebuffer( GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
{
    struct glBlitNamedFramebuffer_params args = { .teb = NtCurrentTeb(), .readFramebuffer = readFramebuffer, .drawFramebuffer = drawFramebuffer, .srcX0 = srcX0, .srcY0 = srcY0, .srcX1 = srcX1, .srcY1 = srcY1, .dstX0 = dstX0, .dstY0 = dstY0, .dstX1 = dstX1, .dstY1 = dstY1, .mask = mask, .filter = filter };
    NTSTATUS status;
    TRACE( "readFramebuffer %d, drawFramebuffer %d, srcX0 %d, srcY0 %d, srcX1 %d, srcY1 %d, dstX0 %d, dstY0 %d, dstX1 %d, dstY1 %d, mask %d, filter %d\n", readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
    if ((status = UNIX_CALL( glBlitNamedFramebuffer, &args ))) WARN( "glBlitNamedFramebuffer returned %#lx\n", status );
}

static void WINAPI glBufferAddressRangeNV( GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length )
{
    struct glBufferAddressRangeNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .index = index, .address = address, .length = length };
    NTSTATUS status;
    TRACE( "pname %d, index %d, address %s, length %Id\n", pname, index, wine_dbgstr_longlong(address), length );
    if ((status = UNIX_CALL( glBufferAddressRangeNV, &args ))) WARN( "glBufferAddressRangeNV returned %#lx\n", status );
}

static void WINAPI glBufferAttachMemoryNV( GLenum target, GLuint memory, GLuint64 offset )
{
    struct glBufferAttachMemoryNV_params args = { .teb = NtCurrentTeb(), .target = target, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, memory %d, offset %s\n", target, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glBufferAttachMemoryNV, &args ))) WARN( "glBufferAttachMemoryNV returned %#lx\n", status );
}

static void WINAPI glBufferData( GLenum target, GLsizeiptr size, const void *data, GLenum usage )
{
    struct glBufferData_params args = { .teb = NtCurrentTeb(), .target = target, .size = size, .data = data, .usage = usage };
    NTSTATUS status;
    TRACE( "target %d, size %Id, data %p, usage %d\n", target, size, data, usage );
    if ((status = UNIX_CALL( glBufferData, &args ))) WARN( "glBufferData returned %#lx\n", status );
}

static void WINAPI glBufferDataARB( GLenum target, GLsizeiptrARB size, const void *data, GLenum usage )
{
    struct glBufferDataARB_params args = { .teb = NtCurrentTeb(), .target = target, .size = size, .data = data, .usage = usage };
    NTSTATUS status;
    TRACE( "target %d, size %Id, data %p, usage %d\n", target, size, data, usage );
    if ((status = UNIX_CALL( glBufferDataARB, &args ))) WARN( "glBufferDataARB returned %#lx\n", status );
}

static void WINAPI glBufferPageCommitmentARB( GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit )
{
    struct glBufferPageCommitmentARB_params args = { .teb = NtCurrentTeb(), .target = target, .offset = offset, .size = size, .commit = commit };
    NTSTATUS status;
    TRACE( "target %d, offset %Id, size %Id, commit %d\n", target, offset, size, commit );
    if ((status = UNIX_CALL( glBufferPageCommitmentARB, &args ))) WARN( "glBufferPageCommitmentARB returned %#lx\n", status );
}

static void WINAPI glBufferParameteriAPPLE( GLenum target, GLenum pname, GLint param )
{
    struct glBufferParameteriAPPLE_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glBufferParameteriAPPLE, &args ))) WARN( "glBufferParameteriAPPLE returned %#lx\n", status );
}

static GLuint WINAPI glBufferRegionEnabled(void)
{
    struct glBufferRegionEnabled_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glBufferRegionEnabled, &args ))) WARN( "glBufferRegionEnabled returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glBufferStorage( GLenum target, GLsizeiptr size, const void *data, GLbitfield flags )
{
    struct glBufferStorage_params args = { .teb = NtCurrentTeb(), .target = target, .size = size, .data = data, .flags = flags };
    NTSTATUS status;
    TRACE( "target %d, size %Id, data %p, flags %d\n", target, size, data, flags );
    if ((status = UNIX_CALL( glBufferStorage, &args ))) WARN( "glBufferStorage returned %#lx\n", status );
}

static void WINAPI glBufferStorageExternalEXT( GLenum target, GLintptr offset, GLsizeiptr size, GLeglClientBufferEXT clientBuffer, GLbitfield flags )
{
    struct glBufferStorageExternalEXT_params args = { .teb = NtCurrentTeb(), .target = target, .offset = offset, .size = size, .clientBuffer = clientBuffer, .flags = flags };
    NTSTATUS status;
    TRACE( "target %d, offset %Id, size %Id, clientBuffer %p, flags %d\n", target, offset, size, clientBuffer, flags );
    if ((status = UNIX_CALL( glBufferStorageExternalEXT, &args ))) WARN( "glBufferStorageExternalEXT returned %#lx\n", status );
}

static void WINAPI glBufferStorageMemEXT( GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset )
{
    struct glBufferStorageMemEXT_params args = { .teb = NtCurrentTeb(), .target = target, .size = size, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, size %Id, memory %d, offset %s\n", target, size, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glBufferStorageMemEXT, &args ))) WARN( "glBufferStorageMemEXT returned %#lx\n", status );
}

static void WINAPI glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void *data )
{
    struct glBufferSubData_params args = { .teb = NtCurrentTeb(), .target = target, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "target %d, offset %Id, size %Id, data %p\n", target, offset, size, data );
    if ((status = UNIX_CALL( glBufferSubData, &args ))) WARN( "glBufferSubData returned %#lx\n", status );
}

static void WINAPI glBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data )
{
    struct glBufferSubDataARB_params args = { .teb = NtCurrentTeb(), .target = target, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "target %d, offset %Id, size %Id, data %p\n", target, offset, size, data );
    if ((status = UNIX_CALL( glBufferSubDataARB, &args ))) WARN( "glBufferSubDataARB returned %#lx\n", status );
}

static void WINAPI glCallCommandListNV( GLuint list )
{
    struct glCallCommandListNV_params args = { .teb = NtCurrentTeb(), .list = list };
    NTSTATUS status;
    TRACE( "list %d\n", list );
    if ((status = UNIX_CALL( glCallCommandListNV, &args ))) WARN( "glCallCommandListNV returned %#lx\n", status );
}

static GLenum WINAPI glCheckFramebufferStatus( GLenum target )
{
    struct glCheckFramebufferStatus_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glCheckFramebufferStatus, &args ))) WARN( "glCheckFramebufferStatus returned %#lx\n", status );
    return args.ret;
}

static GLenum WINAPI glCheckFramebufferStatusEXT( GLenum target )
{
    struct glCheckFramebufferStatusEXT_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glCheckFramebufferStatusEXT, &args ))) WARN( "glCheckFramebufferStatusEXT returned %#lx\n", status );
    return args.ret;
}

static GLenum WINAPI glCheckNamedFramebufferStatus( GLuint framebuffer, GLenum target )
{
    struct glCheckNamedFramebufferStatus_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .target = target };
    NTSTATUS status;
    TRACE( "framebuffer %d, target %d\n", framebuffer, target );
    if ((status = UNIX_CALL( glCheckNamedFramebufferStatus, &args ))) WARN( "glCheckNamedFramebufferStatus returned %#lx\n", status );
    return args.ret;
}

static GLenum WINAPI glCheckNamedFramebufferStatusEXT( GLuint framebuffer, GLenum target )
{
    struct glCheckNamedFramebufferStatusEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .target = target };
    NTSTATUS status;
    TRACE( "framebuffer %d, target %d\n", framebuffer, target );
    if ((status = UNIX_CALL( glCheckNamedFramebufferStatusEXT, &args ))) WARN( "glCheckNamedFramebufferStatusEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glClampColor( GLenum target, GLenum clamp )
{
    struct glClampColor_params args = { .teb = NtCurrentTeb(), .target = target, .clamp = clamp };
    NTSTATUS status;
    TRACE( "target %d, clamp %d\n", target, clamp );
    if ((status = UNIX_CALL( glClampColor, &args ))) WARN( "glClampColor returned %#lx\n", status );
}

static void WINAPI glClampColorARB( GLenum target, GLenum clamp )
{
    struct glClampColorARB_params args = { .teb = NtCurrentTeb(), .target = target, .clamp = clamp };
    NTSTATUS status;
    TRACE( "target %d, clamp %d\n", target, clamp );
    if ((status = UNIX_CALL( glClampColorARB, &args ))) WARN( "glClampColorARB returned %#lx\n", status );
}

static void WINAPI glClearAccumxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha )
{
    struct glClearAccumxOES_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glClearAccumxOES, &args ))) WARN( "glClearAccumxOES returned %#lx\n", status );
}

static void WINAPI glClearBufferData( GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data )
{
    struct glClearBufferData_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, format %d, type %d, data %p\n", target, internalformat, format, type, data );
    if ((status = UNIX_CALL( glClearBufferData, &args ))) WARN( "glClearBufferData returned %#lx\n", status );
}

static void WINAPI glClearBufferSubData( GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data )
{
    struct glClearBufferSubData_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .offset = offset, .size = size, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, offset %Id, size %Id, format %d, type %d, data %p\n", target, internalformat, offset, size, format, type, data );
    if ((status = UNIX_CALL( glClearBufferSubData, &args ))) WARN( "glClearBufferSubData returned %#lx\n", status );
}

static void WINAPI glClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil )
{
    struct glClearBufferfi_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .drawbuffer = drawbuffer, .depth = depth, .stencil = stencil };
    NTSTATUS status;
    TRACE( "buffer %d, drawbuffer %d, depth %f, stencil %d\n", buffer, drawbuffer, depth, stencil );
    if ((status = UNIX_CALL( glClearBufferfi, &args ))) WARN( "glClearBufferfi returned %#lx\n", status );
}

static void WINAPI glClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat *value )
{
    struct glClearBufferfv_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .drawbuffer = drawbuffer, .value = value };
    NTSTATUS status;
    TRACE( "buffer %d, drawbuffer %d, value %p\n", buffer, drawbuffer, value );
    if ((status = UNIX_CALL( glClearBufferfv, &args ))) WARN( "glClearBufferfv returned %#lx\n", status );
}

static void WINAPI glClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint *value )
{
    struct glClearBufferiv_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .drawbuffer = drawbuffer, .value = value };
    NTSTATUS status;
    TRACE( "buffer %d, drawbuffer %d, value %p\n", buffer, drawbuffer, value );
    if ((status = UNIX_CALL( glClearBufferiv, &args ))) WARN( "glClearBufferiv returned %#lx\n", status );
}

static void WINAPI glClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint *value )
{
    struct glClearBufferuiv_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .drawbuffer = drawbuffer, .value = value };
    NTSTATUS status;
    TRACE( "buffer %d, drawbuffer %d, value %p\n", buffer, drawbuffer, value );
    if ((status = UNIX_CALL( glClearBufferuiv, &args ))) WARN( "glClearBufferuiv returned %#lx\n", status );
}

static void WINAPI glClearColorIiEXT( GLint red, GLint green, GLint blue, GLint alpha )
{
    struct glClearColorIiEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glClearColorIiEXT, &args ))) WARN( "glClearColorIiEXT returned %#lx\n", status );
}

static void WINAPI glClearColorIuiEXT( GLuint red, GLuint green, GLuint blue, GLuint alpha )
{
    struct glClearColorIuiEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glClearColorIuiEXT, &args ))) WARN( "glClearColorIuiEXT returned %#lx\n", status );
}

static void WINAPI glClearColorxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha )
{
    struct glClearColorxOES_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glClearColorxOES, &args ))) WARN( "glClearColorxOES returned %#lx\n", status );
}

static void WINAPI glClearDepthdNV( GLdouble depth )
{
    struct glClearDepthdNV_params args = { .teb = NtCurrentTeb(), .depth = depth };
    NTSTATUS status;
    TRACE( "depth %f\n", depth );
    if ((status = UNIX_CALL( glClearDepthdNV, &args ))) WARN( "glClearDepthdNV returned %#lx\n", status );
}

static void WINAPI glClearDepthf( GLfloat d )
{
    struct glClearDepthf_params args = { .teb = NtCurrentTeb(), .d = d };
    NTSTATUS status;
    TRACE( "d %f\n", d );
    if ((status = UNIX_CALL( glClearDepthf, &args ))) WARN( "glClearDepthf returned %#lx\n", status );
}

static void WINAPI glClearDepthfOES( GLclampf depth )
{
    struct glClearDepthfOES_params args = { .teb = NtCurrentTeb(), .depth = depth };
    NTSTATUS status;
    TRACE( "depth %f\n", depth );
    if ((status = UNIX_CALL( glClearDepthfOES, &args ))) WARN( "glClearDepthfOES returned %#lx\n", status );
}

static void WINAPI glClearDepthxOES( GLfixed depth )
{
    struct glClearDepthxOES_params args = { .teb = NtCurrentTeb(), .depth = depth };
    NTSTATUS status;
    TRACE( "depth %d\n", depth );
    if ((status = UNIX_CALL( glClearDepthxOES, &args ))) WARN( "glClearDepthxOES returned %#lx\n", status );
}

static void WINAPI glClearNamedBufferData( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data )
{
    struct glClearNamedBufferData_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .internalformat = internalformat, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "buffer %d, internalformat %d, format %d, type %d, data %p\n", buffer, internalformat, format, type, data );
    if ((status = UNIX_CALL( glClearNamedBufferData, &args ))) WARN( "glClearNamedBufferData returned %#lx\n", status );
}

static void WINAPI glClearNamedBufferDataEXT( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data )
{
    struct glClearNamedBufferDataEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .internalformat = internalformat, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "buffer %d, internalformat %d, format %d, type %d, data %p\n", buffer, internalformat, format, type, data );
    if ((status = UNIX_CALL( glClearNamedBufferDataEXT, &args ))) WARN( "glClearNamedBufferDataEXT returned %#lx\n", status );
}

static void WINAPI glClearNamedBufferSubData( GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data )
{
    struct glClearNamedBufferSubData_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .internalformat = internalformat, .offset = offset, .size = size, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "buffer %d, internalformat %d, offset %Id, size %Id, format %d, type %d, data %p\n", buffer, internalformat, offset, size, format, type, data );
    if ((status = UNIX_CALL( glClearNamedBufferSubData, &args ))) WARN( "glClearNamedBufferSubData returned %#lx\n", status );
}

static void WINAPI glClearNamedBufferSubDataEXT( GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data )
{
    struct glClearNamedBufferSubDataEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .internalformat = internalformat, .offset = offset, .size = size, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "buffer %d, internalformat %d, offset %Id, size %Id, format %d, type %d, data %p\n", buffer, internalformat, offset, size, format, type, data );
    if ((status = UNIX_CALL( glClearNamedBufferSubDataEXT, &args ))) WARN( "glClearNamedBufferSubDataEXT returned %#lx\n", status );
}

static void WINAPI glClearNamedFramebufferfi( GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil )
{
    struct glClearNamedFramebufferfi_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .buffer = buffer, .drawbuffer = drawbuffer, .depth = depth, .stencil = stencil };
    NTSTATUS status;
    TRACE( "framebuffer %d, buffer %d, drawbuffer %d, depth %f, stencil %d\n", framebuffer, buffer, drawbuffer, depth, stencil );
    if ((status = UNIX_CALL( glClearNamedFramebufferfi, &args ))) WARN( "glClearNamedFramebufferfi returned %#lx\n", status );
}

static void WINAPI glClearNamedFramebufferfv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value )
{
    struct glClearNamedFramebufferfv_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .buffer = buffer, .drawbuffer = drawbuffer, .value = value };
    NTSTATUS status;
    TRACE( "framebuffer %d, buffer %d, drawbuffer %d, value %p\n", framebuffer, buffer, drawbuffer, value );
    if ((status = UNIX_CALL( glClearNamedFramebufferfv, &args ))) WARN( "glClearNamedFramebufferfv returned %#lx\n", status );
}

static void WINAPI glClearNamedFramebufferiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value )
{
    struct glClearNamedFramebufferiv_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .buffer = buffer, .drawbuffer = drawbuffer, .value = value };
    NTSTATUS status;
    TRACE( "framebuffer %d, buffer %d, drawbuffer %d, value %p\n", framebuffer, buffer, drawbuffer, value );
    if ((status = UNIX_CALL( glClearNamedFramebufferiv, &args ))) WARN( "glClearNamedFramebufferiv returned %#lx\n", status );
}

static void WINAPI glClearNamedFramebufferuiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value )
{
    struct glClearNamedFramebufferuiv_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .buffer = buffer, .drawbuffer = drawbuffer, .value = value };
    NTSTATUS status;
    TRACE( "framebuffer %d, buffer %d, drawbuffer %d, value %p\n", framebuffer, buffer, drawbuffer, value );
    if ((status = UNIX_CALL( glClearNamedFramebufferuiv, &args ))) WARN( "glClearNamedFramebufferuiv returned %#lx\n", status );
}

static void WINAPI glClearTexImage( GLuint texture, GLint level, GLenum format, GLenum type, const void *data )
{
    struct glClearTexImage_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "texture %d, level %d, format %d, type %d, data %p\n", texture, level, format, type, data );
    if ((status = UNIX_CALL( glClearTexImage, &args ))) WARN( "glClearTexImage returned %#lx\n", status );
}

static void WINAPI glClearTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data )
{
    struct glClearTexSubImage_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, type %d, data %p\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data );
    if ((status = UNIX_CALL( glClearTexSubImage, &args ))) WARN( "glClearTexSubImage returned %#lx\n", status );
}

static void WINAPI glClientActiveTexture( GLenum texture )
{
    struct glClientActiveTexture_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glClientActiveTexture, &args ))) WARN( "glClientActiveTexture returned %#lx\n", status );
}

static void WINAPI glClientActiveTextureARB( GLenum texture )
{
    struct glClientActiveTextureARB_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glClientActiveTextureARB, &args ))) WARN( "glClientActiveTextureARB returned %#lx\n", status );
}

static void WINAPI glClientActiveVertexStreamATI( GLenum stream )
{
    struct glClientActiveVertexStreamATI_params args = { .teb = NtCurrentTeb(), .stream = stream };
    NTSTATUS status;
    TRACE( "stream %d\n", stream );
    if ((status = UNIX_CALL( glClientActiveVertexStreamATI, &args ))) WARN( "glClientActiveVertexStreamATI returned %#lx\n", status );
}

static void WINAPI glClientAttribDefaultEXT( GLbitfield mask )
{
    struct glClientAttribDefaultEXT_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glClientAttribDefaultEXT, &args ))) WARN( "glClientAttribDefaultEXT returned %#lx\n", status );
}

static void WINAPI glClientWaitSemaphoreui64NVX( GLsizei fenceObjectCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray )
{
    struct glClientWaitSemaphoreui64NVX_params args = { .teb = NtCurrentTeb(), .fenceObjectCount = fenceObjectCount, .semaphoreArray = semaphoreArray, .fenceValueArray = fenceValueArray };
    NTSTATUS status;
    TRACE( "fenceObjectCount %d, semaphoreArray %p, fenceValueArray %p\n", fenceObjectCount, semaphoreArray, fenceValueArray );
    if ((status = UNIX_CALL( glClientWaitSemaphoreui64NVX, &args ))) WARN( "glClientWaitSemaphoreui64NVX returned %#lx\n", status );
}

static GLenum WINAPI glClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout )
{
    struct glClientWaitSync_params args = { .teb = NtCurrentTeb(), .sync = sync, .flags = flags, .timeout = timeout };
    NTSTATUS status;
    TRACE( "sync %p, flags %d, timeout %s\n", sync, flags, wine_dbgstr_longlong(timeout) );
    if ((status = UNIX_CALL( glClientWaitSync, &args ))) WARN( "glClientWaitSync returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glClipControl( GLenum origin, GLenum depth )
{
    struct glClipControl_params args = { .teb = NtCurrentTeb(), .origin = origin, .depth = depth };
    NTSTATUS status;
    TRACE( "origin %d, depth %d\n", origin, depth );
    if ((status = UNIX_CALL( glClipControl, &args ))) WARN( "glClipControl returned %#lx\n", status );
}

static void WINAPI glClipPlanefOES( GLenum plane, const GLfloat *equation )
{
    struct glClipPlanefOES_params args = { .teb = NtCurrentTeb(), .plane = plane, .equation = equation };
    NTSTATUS status;
    TRACE( "plane %d, equation %p\n", plane, equation );
    if ((status = UNIX_CALL( glClipPlanefOES, &args ))) WARN( "glClipPlanefOES returned %#lx\n", status );
}

static void WINAPI glClipPlanexOES( GLenum plane, const GLfixed *equation )
{
    struct glClipPlanexOES_params args = { .teb = NtCurrentTeb(), .plane = plane, .equation = equation };
    NTSTATUS status;
    TRACE( "plane %d, equation %p\n", plane, equation );
    if ((status = UNIX_CALL( glClipPlanexOES, &args ))) WARN( "glClipPlanexOES returned %#lx\n", status );
}

static void WINAPI glColor3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z )
{
    struct glColor3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .r = r, .g = g, .b = b, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "r %f, g %f, b %f, x %f, y %f, z %f\n", r, g, b, x, y, z );
    if ((status = UNIX_CALL( glColor3fVertex3fSUN, &args ))) WARN( "glColor3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glColor3fVertex3fvSUN( const GLfloat *c, const GLfloat *v )
{
    struct glColor3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .c = c, .v = v };
    NTSTATUS status;
    TRACE( "c %p, v %p\n", c, v );
    if ((status = UNIX_CALL( glColor3fVertex3fvSUN, &args ))) WARN( "glColor3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glColor3hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue )
{
    struct glColor3hNV_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3hNV, &args ))) WARN( "glColor3hNV returned %#lx\n", status );
}

static void WINAPI glColor3hvNV( const GLhalfNV *v )
{
    struct glColor3hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor3hvNV, &args ))) WARN( "glColor3hvNV returned %#lx\n", status );
}

static void WINAPI glColor3xOES( GLfixed red, GLfixed green, GLfixed blue )
{
    struct glColor3xOES_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glColor3xOES, &args ))) WARN( "glColor3xOES returned %#lx\n", status );
}

static void WINAPI glColor3xvOES( const GLfixed *components )
{
    struct glColor3xvOES_params args = { .teb = NtCurrentTeb(), .components = components };
    NTSTATUS status;
    TRACE( "components %p\n", components );
    if ((status = UNIX_CALL( glColor3xvOES, &args ))) WARN( "glColor3xvOES returned %#lx\n", status );
}

static void WINAPI glColor4fNormal3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
{
    struct glColor4fNormal3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .r = r, .g = g, .b = b, .a = a, .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "r %f, g %f, b %f, a %f, nx %f, ny %f, nz %f, x %f, y %f, z %f\n", r, g, b, a, nx, ny, nz, x, y, z );
    if ((status = UNIX_CALL( glColor4fNormal3fVertex3fSUN, &args ))) WARN( "glColor4fNormal3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glColor4fNormal3fVertex3fvSUN( const GLfloat *c, const GLfloat *n, const GLfloat *v )
{
    struct glColor4fNormal3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .c = c, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "c %p, n %p, v %p\n", c, n, v );
    if ((status = UNIX_CALL( glColor4fNormal3fVertex3fvSUN, &args ))) WARN( "glColor4fNormal3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glColor4hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha )
{
    struct glColor4hNV_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4hNV, &args ))) WARN( "glColor4hNV returned %#lx\n", status );
}

static void WINAPI glColor4hvNV( const GLhalfNV *v )
{
    struct glColor4hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glColor4hvNV, &args ))) WARN( "glColor4hvNV returned %#lx\n", status );
}

static void WINAPI glColor4ubVertex2fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y )
{
    struct glColor4ubVertex2fSUN_params args = { .teb = NtCurrentTeb(), .r = r, .g = g, .b = b, .a = a, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "r %d, g %d, b %d, a %d, x %f, y %f\n", r, g, b, a, x, y );
    if ((status = UNIX_CALL( glColor4ubVertex2fSUN, &args ))) WARN( "glColor4ubVertex2fSUN returned %#lx\n", status );
}

static void WINAPI glColor4ubVertex2fvSUN( const GLubyte *c, const GLfloat *v )
{
    struct glColor4ubVertex2fvSUN_params args = { .teb = NtCurrentTeb(), .c = c, .v = v };
    NTSTATUS status;
    TRACE( "c %p, v %p\n", c, v );
    if ((status = UNIX_CALL( glColor4ubVertex2fvSUN, &args ))) WARN( "glColor4ubVertex2fvSUN returned %#lx\n", status );
}

static void WINAPI glColor4ubVertex3fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z )
{
    struct glColor4ubVertex3fSUN_params args = { .teb = NtCurrentTeb(), .r = r, .g = g, .b = b, .a = a, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "r %d, g %d, b %d, a %d, x %f, y %f, z %f\n", r, g, b, a, x, y, z );
    if ((status = UNIX_CALL( glColor4ubVertex3fSUN, &args ))) WARN( "glColor4ubVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glColor4ubVertex3fvSUN( const GLubyte *c, const GLfloat *v )
{
    struct glColor4ubVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .c = c, .v = v };
    NTSTATUS status;
    TRACE( "c %p, v %p\n", c, v );
    if ((status = UNIX_CALL( glColor4ubVertex3fvSUN, &args ))) WARN( "glColor4ubVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glColor4xOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha )
{
    struct glColor4xOES_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glColor4xOES, &args ))) WARN( "glColor4xOES returned %#lx\n", status );
}

static void WINAPI glColor4xvOES( const GLfixed *components )
{
    struct glColor4xvOES_params args = { .teb = NtCurrentTeb(), .components = components };
    NTSTATUS status;
    TRACE( "components %p\n", components );
    if ((status = UNIX_CALL( glColor4xvOES, &args ))) WARN( "glColor4xvOES returned %#lx\n", status );
}

static void WINAPI glColorFormatNV( GLint size, GLenum type, GLsizei stride )
{
    struct glColorFormatNV_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d\n", size, type, stride );
    if ((status = UNIX_CALL( glColorFormatNV, &args ))) WARN( "glColorFormatNV returned %#lx\n", status );
}

static void WINAPI glColorFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod )
{
    struct glColorFragmentOp1ATI_params args = { .teb = NtCurrentTeb(), .op = op, .dst = dst, .dstMask = dstMask, .dstMod = dstMod, .arg1 = arg1, .arg1Rep = arg1Rep, .arg1Mod = arg1Mod };
    NTSTATUS status;
    TRACE( "op %d, dst %d, dstMask %d, dstMod %d, arg1 %d, arg1Rep %d, arg1Mod %d\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod );
    if ((status = UNIX_CALL( glColorFragmentOp1ATI, &args ))) WARN( "glColorFragmentOp1ATI returned %#lx\n", status );
}

static void WINAPI glColorFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod )
{
    struct glColorFragmentOp2ATI_params args = { .teb = NtCurrentTeb(), .op = op, .dst = dst, .dstMask = dstMask, .dstMod = dstMod, .arg1 = arg1, .arg1Rep = arg1Rep, .arg1Mod = arg1Mod, .arg2 = arg2, .arg2Rep = arg2Rep, .arg2Mod = arg2Mod };
    NTSTATUS status;
    TRACE( "op %d, dst %d, dstMask %d, dstMod %d, arg1 %d, arg1Rep %d, arg1Mod %d, arg2 %d, arg2Rep %d, arg2Mod %d\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod );
    if ((status = UNIX_CALL( glColorFragmentOp2ATI, &args ))) WARN( "glColorFragmentOp2ATI returned %#lx\n", status );
}

static void WINAPI glColorFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod )
{
    struct glColorFragmentOp3ATI_params args = { .teb = NtCurrentTeb(), .op = op, .dst = dst, .dstMask = dstMask, .dstMod = dstMod, .arg1 = arg1, .arg1Rep = arg1Rep, .arg1Mod = arg1Mod, .arg2 = arg2, .arg2Rep = arg2Rep, .arg2Mod = arg2Mod, .arg3 = arg3, .arg3Rep = arg3Rep, .arg3Mod = arg3Mod };
    NTSTATUS status;
    TRACE( "op %d, dst %d, dstMask %d, dstMod %d, arg1 %d, arg1Rep %d, arg1Mod %d, arg2 %d, arg2Rep %d, arg2Mod %d, arg3 %d, arg3Rep %d, arg3Mod %d\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod );
    if ((status = UNIX_CALL( glColorFragmentOp3ATI, &args ))) WARN( "glColorFragmentOp3ATI returned %#lx\n", status );
}

static void WINAPI glColorMaskIndexedEXT( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a )
{
    struct glColorMaskIndexedEXT_params args = { .teb = NtCurrentTeb(), .index = index, .r = r, .g = g, .b = b, .a = a };
    NTSTATUS status;
    TRACE( "index %d, r %d, g %d, b %d, a %d\n", index, r, g, b, a );
    if ((status = UNIX_CALL( glColorMaskIndexedEXT, &args ))) WARN( "glColorMaskIndexedEXT returned %#lx\n", status );
}

static void WINAPI glColorMaski( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a )
{
    struct glColorMaski_params args = { .teb = NtCurrentTeb(), .index = index, .r = r, .g = g, .b = b, .a = a };
    NTSTATUS status;
    TRACE( "index %d, r %d, g %d, b %d, a %d\n", index, r, g, b, a );
    if ((status = UNIX_CALL( glColorMaski, &args ))) WARN( "glColorMaski returned %#lx\n", status );
}

static void WINAPI glColorP3ui( GLenum type, GLuint color )
{
    struct glColorP3ui_params args = { .teb = NtCurrentTeb(), .type = type, .color = color };
    NTSTATUS status;
    TRACE( "type %d, color %d\n", type, color );
    if ((status = UNIX_CALL( glColorP3ui, &args ))) WARN( "glColorP3ui returned %#lx\n", status );
}

static void WINAPI glColorP3uiv( GLenum type, const GLuint *color )
{
    struct glColorP3uiv_params args = { .teb = NtCurrentTeb(), .type = type, .color = color };
    NTSTATUS status;
    TRACE( "type %d, color %p\n", type, color );
    if ((status = UNIX_CALL( glColorP3uiv, &args ))) WARN( "glColorP3uiv returned %#lx\n", status );
}

static void WINAPI glColorP4ui( GLenum type, GLuint color )
{
    struct glColorP4ui_params args = { .teb = NtCurrentTeb(), .type = type, .color = color };
    NTSTATUS status;
    TRACE( "type %d, color %d\n", type, color );
    if ((status = UNIX_CALL( glColorP4ui, &args ))) WARN( "glColorP4ui returned %#lx\n", status );
}

static void WINAPI glColorP4uiv( GLenum type, const GLuint *color )
{
    struct glColorP4uiv_params args = { .teb = NtCurrentTeb(), .type = type, .color = color };
    NTSTATUS status;
    TRACE( "type %d, color %p\n", type, color );
    if ((status = UNIX_CALL( glColorP4uiv, &args ))) WARN( "glColorP4uiv returned %#lx\n", status );
}

static void WINAPI glColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer )
{
    struct glColorPointerEXT_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .count = count, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, count %d, pointer %p\n", size, type, stride, count, pointer );
    if ((status = UNIX_CALL( glColorPointerEXT, &args ))) WARN( "glColorPointerEXT returned %#lx\n", status );
}

static void WINAPI glColorPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride )
{
    struct glColorPointerListIBM_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer, .ptrstride = ptrstride };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p, ptrstride %d\n", size, type, stride, pointer, ptrstride );
    if ((status = UNIX_CALL( glColorPointerListIBM, &args ))) WARN( "glColorPointerListIBM returned %#lx\n", status );
}

static void WINAPI glColorPointervINTEL( GLint size, GLenum type, const void **pointer )
{
    struct glColorPointervINTEL_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, pointer %p\n", size, type, pointer );
    if ((status = UNIX_CALL( glColorPointervINTEL, &args ))) WARN( "glColorPointervINTEL returned %#lx\n", status );
}

static void WINAPI glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data )
{
    struct glColorSubTable_params args = { .teb = NtCurrentTeb(), .target = target, .start = start, .count = count, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "target %d, start %d, count %d, format %d, type %d, data %p\n", target, start, count, format, type, data );
    if ((status = UNIX_CALL( glColorSubTable, &args ))) WARN( "glColorSubTable returned %#lx\n", status );
}

static void WINAPI glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data )
{
    struct glColorSubTableEXT_params args = { .teb = NtCurrentTeb(), .target = target, .start = start, .count = count, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "target %d, start %d, count %d, format %d, type %d, data %p\n", target, start, count, format, type, data );
    if ((status = UNIX_CALL( glColorSubTableEXT, &args ))) WARN( "glColorSubTableEXT returned %#lx\n", status );
}

static void WINAPI glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table )
{
    struct glColorTable_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .format = format, .type = type, .table = table };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, format %d, type %d, table %p\n", target, internalformat, width, format, type, table );
    if ((status = UNIX_CALL( glColorTable, &args ))) WARN( "glColorTable returned %#lx\n", status );
}

static void WINAPI glColorTableEXT( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *table )
{
    struct glColorTableEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalFormat = internalFormat, .width = width, .format = format, .type = type, .table = table };
    NTSTATUS status;
    TRACE( "target %d, internalFormat %d, width %d, format %d, type %d, table %p\n", target, internalFormat, width, format, type, table );
    if ((status = UNIX_CALL( glColorTableEXT, &args ))) WARN( "glColorTableEXT returned %#lx\n", status );
}

static void WINAPI glColorTableParameterfv( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glColorTableParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glColorTableParameterfv, &args ))) WARN( "glColorTableParameterfv returned %#lx\n", status );
}

static void WINAPI glColorTableParameterfvSGI( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glColorTableParameterfvSGI_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glColorTableParameterfvSGI, &args ))) WARN( "glColorTableParameterfvSGI returned %#lx\n", status );
}

static void WINAPI glColorTableParameteriv( GLenum target, GLenum pname, const GLint *params )
{
    struct glColorTableParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glColorTableParameteriv, &args ))) WARN( "glColorTableParameteriv returned %#lx\n", status );
}

static void WINAPI glColorTableParameterivSGI( GLenum target, GLenum pname, const GLint *params )
{
    struct glColorTableParameterivSGI_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glColorTableParameterivSGI, &args ))) WARN( "glColorTableParameterivSGI returned %#lx\n", status );
}

static void WINAPI glColorTableSGI( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table )
{
    struct glColorTableSGI_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .format = format, .type = type, .table = table };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, format %d, type %d, table %p\n", target, internalformat, width, format, type, table );
    if ((status = UNIX_CALL( glColorTableSGI, &args ))) WARN( "glColorTableSGI returned %#lx\n", status );
}

static void WINAPI glCombinerInputNV( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage )
{
    struct glCombinerInputNV_params args = { .teb = NtCurrentTeb(), .stage = stage, .portion = portion, .variable = variable, .input = input, .mapping = mapping, .componentUsage = componentUsage };
    NTSTATUS status;
    TRACE( "stage %d, portion %d, variable %d, input %d, mapping %d, componentUsage %d\n", stage, portion, variable, input, mapping, componentUsage );
    if ((status = UNIX_CALL( glCombinerInputNV, &args ))) WARN( "glCombinerInputNV returned %#lx\n", status );
}

static void WINAPI glCombinerOutputNV( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum )
{
    struct glCombinerOutputNV_params args = { .teb = NtCurrentTeb(), .stage = stage, .portion = portion, .abOutput = abOutput, .cdOutput = cdOutput, .sumOutput = sumOutput, .scale = scale, .bias = bias, .abDotProduct = abDotProduct, .cdDotProduct = cdDotProduct, .muxSum = muxSum };
    NTSTATUS status;
    TRACE( "stage %d, portion %d, abOutput %d, cdOutput %d, sumOutput %d, scale %d, bias %d, abDotProduct %d, cdDotProduct %d, muxSum %d\n", stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum );
    if ((status = UNIX_CALL( glCombinerOutputNV, &args ))) WARN( "glCombinerOutputNV returned %#lx\n", status );
}

static void WINAPI glCombinerParameterfNV( GLenum pname, GLfloat param )
{
    struct glCombinerParameterfNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glCombinerParameterfNV, &args ))) WARN( "glCombinerParameterfNV returned %#lx\n", status );
}

static void WINAPI glCombinerParameterfvNV( GLenum pname, const GLfloat *params )
{
    struct glCombinerParameterfvNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glCombinerParameterfvNV, &args ))) WARN( "glCombinerParameterfvNV returned %#lx\n", status );
}

static void WINAPI glCombinerParameteriNV( GLenum pname, GLint param )
{
    struct glCombinerParameteriNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glCombinerParameteriNV, &args ))) WARN( "glCombinerParameteriNV returned %#lx\n", status );
}

static void WINAPI glCombinerParameterivNV( GLenum pname, const GLint *params )
{
    struct glCombinerParameterivNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glCombinerParameterivNV, &args ))) WARN( "glCombinerParameterivNV returned %#lx\n", status );
}

static void WINAPI glCombinerStageParameterfvNV( GLenum stage, GLenum pname, const GLfloat *params )
{
    struct glCombinerStageParameterfvNV_params args = { .teb = NtCurrentTeb(), .stage = stage, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "stage %d, pname %d, params %p\n", stage, pname, params );
    if ((status = UNIX_CALL( glCombinerStageParameterfvNV, &args ))) WARN( "glCombinerStageParameterfvNV returned %#lx\n", status );
}

static void WINAPI glCommandListSegmentsNV( GLuint list, GLuint segments )
{
    struct glCommandListSegmentsNV_params args = { .teb = NtCurrentTeb(), .list = list, .segments = segments };
    NTSTATUS status;
    TRACE( "list %d, segments %d\n", list, segments );
    if ((status = UNIX_CALL( glCommandListSegmentsNV, &args ))) WARN( "glCommandListSegmentsNV returned %#lx\n", status );
}

static void WINAPI glCompileCommandListNV( GLuint list )
{
    struct glCompileCommandListNV_params args = { .teb = NtCurrentTeb(), .list = list };
    NTSTATUS status;
    TRACE( "list %d\n", list );
    if ((status = UNIX_CALL( glCompileCommandListNV, &args ))) WARN( "glCompileCommandListNV returned %#lx\n", status );
}

static void WINAPI glCompileShader( GLuint shader )
{
    struct glCompileShader_params args = { .teb = NtCurrentTeb(), .shader = shader };
    NTSTATUS status;
    TRACE( "shader %d\n", shader );
    if ((status = UNIX_CALL( glCompileShader, &args ))) WARN( "glCompileShader returned %#lx\n", status );
}

static void WINAPI glCompileShaderARB( GLhandleARB shaderObj )
{
    struct glCompileShaderARB_params args = { .teb = NtCurrentTeb(), .shaderObj = shaderObj };
    NTSTATUS status;
    TRACE( "shaderObj %d\n", shaderObj );
    if ((status = UNIX_CALL( glCompileShaderARB, &args ))) WARN( "glCompileShaderARB returned %#lx\n", status );
}

static void WINAPI glCompileShaderIncludeARB( GLuint shader, GLsizei count, const GLchar *const*path, const GLint *length )
{
    struct glCompileShaderIncludeARB_params args = { .teb = NtCurrentTeb(), .shader = shader, .count = count, .path = path, .length = length };
    NTSTATUS status;
    TRACE( "shader %d, count %d, path %p, length %p\n", shader, count, path, length );
    if ((status = UNIX_CALL( glCompileShaderIncludeARB, &args ))) WARN( "glCompileShaderIncludeARB returned %#lx\n", status );
}

static void WINAPI glCompressedMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits )
{
    struct glCompressedMultiTexImage1DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .internalformat = internalformat, .width = width, .border = border, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, internalformat %d, width %d, border %d, imageSize %d, bits %p\n", texunit, target, level, internalformat, width, border, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedMultiTexImage1DEXT, &args ))) WARN( "glCompressedMultiTexImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits )
{
    struct glCompressedMultiTexImage2DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .border = border, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, internalformat %d, width %d, height %d, border %d, imageSize %d, bits %p\n", texunit, target, level, internalformat, width, height, border, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedMultiTexImage2DEXT, &args ))) WARN( "glCompressedMultiTexImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits )
{
    struct glCompressedMultiTexImage3DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .border = border, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, internalformat %d, width %d, height %d, depth %d, border %d, imageSize %d, bits %p\n", texunit, target, level, internalformat, width, height, depth, border, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedMultiTexImage3DEXT, &args ))) WARN( "glCompressedMultiTexImage3DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits )
{
    struct glCompressedMultiTexSubImage1DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, width %d, format %d, imageSize %d, bits %p\n", texunit, target, level, xoffset, width, format, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedMultiTexSubImage1DEXT, &args ))) WARN( "glCompressedMultiTexSubImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits )
{
    struct glCompressedMultiTexSubImage2DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, imageSize %d, bits %p\n", texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedMultiTexSubImage2DEXT, &args ))) WARN( "glCompressedMultiTexSubImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits )
{
    struct glCompressedMultiTexSubImage3DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, imageSize %d, bits %p\n", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedMultiTexSubImage3DEXT, &args ))) WARN( "glCompressedMultiTexSubImage3DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data )
{
    struct glCompressedTexImage1D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .border = border, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, border %d, imageSize %d, data %p\n", target, level, internalformat, width, border, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexImage1D, &args ))) WARN( "glCompressedTexImage1D returned %#lx\n", status );
}

static void WINAPI glCompressedTexImage1DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data )
{
    struct glCompressedTexImage1DARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .border = border, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, border %d, imageSize %d, data %p\n", target, level, internalformat, width, border, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexImage1DARB, &args ))) WARN( "glCompressedTexImage1DARB returned %#lx\n", status );
}

static void WINAPI glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data )
{
    struct glCompressedTexImage2D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .border = border, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, border %d, imageSize %d, data %p\n", target, level, internalformat, width, height, border, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexImage2D, &args ))) WARN( "glCompressedTexImage2D returned %#lx\n", status );
}

static void WINAPI glCompressedTexImage2DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data )
{
    struct glCompressedTexImage2DARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .border = border, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, border %d, imageSize %d, data %p\n", target, level, internalformat, width, height, border, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexImage2DARB, &args ))) WARN( "glCompressedTexImage2DARB returned %#lx\n", status );
}

static void WINAPI glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data )
{
    struct glCompressedTexImage3D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .border = border, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, depth %d, border %d, imageSize %d, data %p\n", target, level, internalformat, width, height, depth, border, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexImage3D, &args ))) WARN( "glCompressedTexImage3D returned %#lx\n", status );
}

static void WINAPI glCompressedTexImage3DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data )
{
    struct glCompressedTexImage3DARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .border = border, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, depth %d, border %d, imageSize %d, data %p\n", target, level, internalformat, width, height, depth, border, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexImage3DARB, &args ))) WARN( "glCompressedTexImage3DARB returned %#lx\n", status );
}

static void WINAPI glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTexSubImage1D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, width %d, format %d, imageSize %d, data %p\n", target, level, xoffset, width, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexSubImage1D, &args ))) WARN( "glCompressedTexSubImage1D returned %#lx\n", status );
}

static void WINAPI glCompressedTexSubImage1DARB( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTexSubImage1DARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, width %d, format %d, imageSize %d, data %p\n", target, level, xoffset, width, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexSubImage1DARB, &args ))) WARN( "glCompressedTexSubImage1DARB returned %#lx\n", status );
}

static void WINAPI glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTexSubImage2D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, imageSize %d, data %p\n", target, level, xoffset, yoffset, width, height, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexSubImage2D, &args ))) WARN( "glCompressedTexSubImage2D returned %#lx\n", status );
}

static void WINAPI glCompressedTexSubImage2DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTexSubImage2DARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, imageSize %d, data %p\n", target, level, xoffset, yoffset, width, height, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexSubImage2DARB, &args ))) WARN( "glCompressedTexSubImage2DARB returned %#lx\n", status );
}

static void WINAPI glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTexSubImage3D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, imageSize %d, data %p\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexSubImage3D, &args ))) WARN( "glCompressedTexSubImage3D returned %#lx\n", status );
}

static void WINAPI glCompressedTexSubImage3DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTexSubImage3DARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, imageSize %d, data %p\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTexSubImage3DARB, &args ))) WARN( "glCompressedTexSubImage3DARB returned %#lx\n", status );
}

static void WINAPI glCompressedTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits )
{
    struct glCompressedTextureImage1DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .internalformat = internalformat, .width = width, .border = border, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, internalformat %d, width %d, border %d, imageSize %d, bits %p\n", texture, target, level, internalformat, width, border, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedTextureImage1DEXT, &args ))) WARN( "glCompressedTextureImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits )
{
    struct glCompressedTextureImage2DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .border = border, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, internalformat %d, width %d, height %d, border %d, imageSize %d, bits %p\n", texture, target, level, internalformat, width, height, border, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedTextureImage2DEXT, &args ))) WARN( "glCompressedTextureImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits )
{
    struct glCompressedTextureImage3DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .border = border, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, internalformat %d, width %d, height %d, depth %d, border %d, imageSize %d, bits %p\n", texture, target, level, internalformat, width, height, depth, border, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedTextureImage3DEXT, &args ))) WARN( "glCompressedTextureImage3DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTextureSubImage1D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .width = width, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, width %d, format %d, imageSize %d, data %p\n", texture, level, xoffset, width, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTextureSubImage1D, &args ))) WARN( "glCompressedTextureSubImage1D returned %#lx\n", status );
}

static void WINAPI glCompressedTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits )
{
    struct glCompressedTextureSubImage1DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, width %d, format %d, imageSize %d, bits %p\n", texture, target, level, xoffset, width, format, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedTextureSubImage1DEXT, &args ))) WARN( "glCompressedTextureSubImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTextureSubImage2D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, imageSize %d, data %p\n", texture, level, xoffset, yoffset, width, height, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTextureSubImage2D, &args ))) WARN( "glCompressedTextureSubImage2D returned %#lx\n", status );
}

static void WINAPI glCompressedTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits )
{
    struct glCompressedTextureSubImage2DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, imageSize %d, bits %p\n", texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedTextureSubImage2DEXT, &args ))) WARN( "glCompressedTextureSubImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCompressedTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data )
{
    struct glCompressedTextureSubImage3D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .imageSize = imageSize, .data = data };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, imageSize %d, data %p\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
    if ((status = UNIX_CALL( glCompressedTextureSubImage3D, &args ))) WARN( "glCompressedTextureSubImage3D returned %#lx\n", status );
}

static void WINAPI glCompressedTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits )
{
    struct glCompressedTextureSubImage3DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .imageSize = imageSize, .bits = bits };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, imageSize %d, bits %p\n", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits );
    if ((status = UNIX_CALL( glCompressedTextureSubImage3DEXT, &args ))) WARN( "glCompressedTextureSubImage3DEXT returned %#lx\n", status );
}

static void WINAPI glConservativeRasterParameterfNV( GLenum pname, GLfloat value )
{
    struct glConservativeRasterParameterfNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "pname %d, value %f\n", pname, value );
    if ((status = UNIX_CALL( glConservativeRasterParameterfNV, &args ))) WARN( "glConservativeRasterParameterfNV returned %#lx\n", status );
}

static void WINAPI glConservativeRasterParameteriNV( GLenum pname, GLint param )
{
    struct glConservativeRasterParameteriNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glConservativeRasterParameteriNV, &args ))) WARN( "glConservativeRasterParameteriNV returned %#lx\n", status );
}

static void WINAPI glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image )
{
    struct glConvolutionFilter1D_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .format = format, .type = type, .image = image };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, format %d, type %d, image %p\n", target, internalformat, width, format, type, image );
    if ((status = UNIX_CALL( glConvolutionFilter1D, &args ))) WARN( "glConvolutionFilter1D returned %#lx\n", status );
}

static void WINAPI glConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image )
{
    struct glConvolutionFilter1DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .format = format, .type = type, .image = image };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, format %d, type %d, image %p\n", target, internalformat, width, format, type, image );
    if ((status = UNIX_CALL( glConvolutionFilter1DEXT, &args ))) WARN( "glConvolutionFilter1DEXT returned %#lx\n", status );
}

static void WINAPI glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image )
{
    struct glConvolutionFilter2D_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .height = height, .format = format, .type = type, .image = image };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, height %d, format %d, type %d, image %p\n", target, internalformat, width, height, format, type, image );
    if ((status = UNIX_CALL( glConvolutionFilter2D, &args ))) WARN( "glConvolutionFilter2D returned %#lx\n", status );
}

static void WINAPI glConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image )
{
    struct glConvolutionFilter2DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .height = height, .format = format, .type = type, .image = image };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, height %d, format %d, type %d, image %p\n", target, internalformat, width, height, format, type, image );
    if ((status = UNIX_CALL( glConvolutionFilter2DEXT, &args ))) WARN( "glConvolutionFilter2DEXT returned %#lx\n", status );
}

static void WINAPI glConvolutionParameterf( GLenum target, GLenum pname, GLfloat params )
{
    struct glConvolutionParameterf_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %f\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameterf, &args ))) WARN( "glConvolutionParameterf returned %#lx\n", status );
}

static void WINAPI glConvolutionParameterfEXT( GLenum target, GLenum pname, GLfloat params )
{
    struct glConvolutionParameterfEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %f\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameterfEXT, &args ))) WARN( "glConvolutionParameterfEXT returned %#lx\n", status );
}

static void WINAPI glConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glConvolutionParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameterfv, &args ))) WARN( "glConvolutionParameterfv returned %#lx\n", status );
}

static void WINAPI glConvolutionParameterfvEXT( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glConvolutionParameterfvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameterfvEXT, &args ))) WARN( "glConvolutionParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glConvolutionParameteri( GLenum target, GLenum pname, GLint params )
{
    struct glConvolutionParameteri_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %d\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameteri, &args ))) WARN( "glConvolutionParameteri returned %#lx\n", status );
}

static void WINAPI glConvolutionParameteriEXT( GLenum target, GLenum pname, GLint params )
{
    struct glConvolutionParameteriEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %d\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameteriEXT, &args ))) WARN( "glConvolutionParameteriEXT returned %#lx\n", status );
}

static void WINAPI glConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params )
{
    struct glConvolutionParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameteriv, &args ))) WARN( "glConvolutionParameteriv returned %#lx\n", status );
}

static void WINAPI glConvolutionParameterivEXT( GLenum target, GLenum pname, const GLint *params )
{
    struct glConvolutionParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameterivEXT, &args ))) WARN( "glConvolutionParameterivEXT returned %#lx\n", status );
}

static void WINAPI glConvolutionParameterxOES( GLenum target, GLenum pname, GLfixed param )
{
    struct glConvolutionParameterxOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glConvolutionParameterxOES, &args ))) WARN( "glConvolutionParameterxOES returned %#lx\n", status );
}

static void WINAPI glConvolutionParameterxvOES( GLenum target, GLenum pname, const GLfixed *params )
{
    struct glConvolutionParameterxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glConvolutionParameterxvOES, &args ))) WARN( "glConvolutionParameterxvOES returned %#lx\n", status );
}

static void WINAPI glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
{
    struct glCopyBufferSubData_params args = { .teb = NtCurrentTeb(), .readTarget = readTarget, .writeTarget = writeTarget, .readOffset = readOffset, .writeOffset = writeOffset, .size = size };
    NTSTATUS status;
    TRACE( "readTarget %d, writeTarget %d, readOffset %Id, writeOffset %Id, size %Id\n", readTarget, writeTarget, readOffset, writeOffset, size );
    if ((status = UNIX_CALL( glCopyBufferSubData, &args ))) WARN( "glCopyBufferSubData returned %#lx\n", status );
}

static void WINAPI glCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width )
{
    struct glCopyColorSubTable_params args = { .teb = NtCurrentTeb(), .target = target, .start = start, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "target %d, start %d, x %d, y %d, width %d\n", target, start, x, y, width );
    if ((status = UNIX_CALL( glCopyColorSubTable, &args ))) WARN( "glCopyColorSubTable returned %#lx\n", status );
}

static void WINAPI glCopyColorSubTableEXT( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width )
{
    struct glCopyColorSubTableEXT_params args = { .teb = NtCurrentTeb(), .target = target, .start = start, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "target %d, start %d, x %d, y %d, width %d\n", target, start, x, y, width );
    if ((status = UNIX_CALL( glCopyColorSubTableEXT, &args ))) WARN( "glCopyColorSubTableEXT returned %#lx\n", status );
}

static void WINAPI glCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
{
    struct glCopyColorTable_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, x %d, y %d, width %d\n", target, internalformat, x, y, width );
    if ((status = UNIX_CALL( glCopyColorTable, &args ))) WARN( "glCopyColorTable returned %#lx\n", status );
}

static void WINAPI glCopyColorTableSGI( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
{
    struct glCopyColorTableSGI_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, x %d, y %d, width %d\n", target, internalformat, x, y, width );
    if ((status = UNIX_CALL( glCopyColorTableSGI, &args ))) WARN( "glCopyColorTableSGI returned %#lx\n", status );
}

static void WINAPI glCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
{
    struct glCopyConvolutionFilter1D_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, x %d, y %d, width %d\n", target, internalformat, x, y, width );
    if ((status = UNIX_CALL( glCopyConvolutionFilter1D, &args ))) WARN( "glCopyConvolutionFilter1D returned %#lx\n", status );
}

static void WINAPI glCopyConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
{
    struct glCopyConvolutionFilter1DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, x %d, y %d, width %d\n", target, internalformat, x, y, width );
    if ((status = UNIX_CALL( glCopyConvolutionFilter1DEXT, &args ))) WARN( "glCopyConvolutionFilter1DEXT returned %#lx\n", status );
}

static void WINAPI glCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyConvolutionFilter2D_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, x %d, y %d, width %d, height %d\n", target, internalformat, x, y, width, height );
    if ((status = UNIX_CALL( glCopyConvolutionFilter2D, &args ))) WARN( "glCopyConvolutionFilter2D returned %#lx\n", status );
}

static void WINAPI glCopyConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyConvolutionFilter2DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, x %d, y %d, width %d, height %d\n", target, internalformat, x, y, width, height );
    if ((status = UNIX_CALL( glCopyConvolutionFilter2DEXT, &args ))) WARN( "glCopyConvolutionFilter2DEXT returned %#lx\n", status );
}

static void WINAPI glCopyImageSubData( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth )
{
    struct glCopyImageSubData_params args = { .teb = NtCurrentTeb(), .srcName = srcName, .srcTarget = srcTarget, .srcLevel = srcLevel, .srcX = srcX, .srcY = srcY, .srcZ = srcZ, .dstName = dstName, .dstTarget = dstTarget, .dstLevel = dstLevel, .dstX = dstX, .dstY = dstY, .dstZ = dstZ, .srcWidth = srcWidth, .srcHeight = srcHeight, .srcDepth = srcDepth };
    NTSTATUS status;
    TRACE( "srcName %d, srcTarget %d, srcLevel %d, srcX %d, srcY %d, srcZ %d, dstName %d, dstTarget %d, dstLevel %d, dstX %d, dstY %d, dstZ %d, srcWidth %d, srcHeight %d, srcDepth %d\n", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
    if ((status = UNIX_CALL( glCopyImageSubData, &args ))) WARN( "glCopyImageSubData returned %#lx\n", status );
}

static void WINAPI glCopyImageSubDataNV( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth )
{
    struct glCopyImageSubDataNV_params args = { .teb = NtCurrentTeb(), .srcName = srcName, .srcTarget = srcTarget, .srcLevel = srcLevel, .srcX = srcX, .srcY = srcY, .srcZ = srcZ, .dstName = dstName, .dstTarget = dstTarget, .dstLevel = dstLevel, .dstX = dstX, .dstY = dstY, .dstZ = dstZ, .width = width, .height = height, .depth = depth };
    NTSTATUS status;
    TRACE( "srcName %d, srcTarget %d, srcLevel %d, srcX %d, srcY %d, srcZ %d, dstName %d, dstTarget %d, dstLevel %d, dstX %d, dstY %d, dstZ %d, width %d, height %d, depth %d\n", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth );
    if ((status = UNIX_CALL( glCopyImageSubDataNV, &args ))) WARN( "glCopyImageSubDataNV returned %#lx\n", status );
}

static void WINAPI glCopyMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
{
    struct glCopyMultiTexImage1DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .border = border };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, internalformat %d, x %d, y %d, width %d, border %d\n", texunit, target, level, internalformat, x, y, width, border );
    if ((status = UNIX_CALL( glCopyMultiTexImage1DEXT, &args ))) WARN( "glCopyMultiTexImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCopyMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
{
    struct glCopyMultiTexImage2DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .height = height, .border = border };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, internalformat %d, x %d, y %d, width %d, height %d, border %d\n", texunit, target, level, internalformat, x, y, width, height, border );
    if ((status = UNIX_CALL( glCopyMultiTexImage2DEXT, &args ))) WARN( "glCopyMultiTexImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCopyMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
{
    struct glCopyMultiTexSubImage1DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, x %d, y %d, width %d\n", texunit, target, level, xoffset, x, y, width );
    if ((status = UNIX_CALL( glCopyMultiTexSubImage1DEXT, &args ))) WARN( "glCopyMultiTexSubImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCopyMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyMultiTexSubImage2DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, yoffset %d, x %d, y %d, width %d, height %d\n", texunit, target, level, xoffset, yoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyMultiTexSubImage2DEXT, &args ))) WARN( "glCopyMultiTexSubImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCopyMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyMultiTexSubImage3DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, yoffset %d, zoffset %d, x %d, y %d, width %d, height %d\n", texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyMultiTexSubImage3DEXT, &args ))) WARN( "glCopyMultiTexSubImage3DEXT returned %#lx\n", status );
}

static void WINAPI glCopyNamedBufferSubData( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
{
    struct glCopyNamedBufferSubData_params args = { .teb = NtCurrentTeb(), .readBuffer = readBuffer, .writeBuffer = writeBuffer, .readOffset = readOffset, .writeOffset = writeOffset, .size = size };
    NTSTATUS status;
    TRACE( "readBuffer %d, writeBuffer %d, readOffset %Id, writeOffset %Id, size %Id\n", readBuffer, writeBuffer, readOffset, writeOffset, size );
    if ((status = UNIX_CALL( glCopyNamedBufferSubData, &args ))) WARN( "glCopyNamedBufferSubData returned %#lx\n", status );
}

static void WINAPI glCopyPathNV( GLuint resultPath, GLuint srcPath )
{
    struct glCopyPathNV_params args = { .teb = NtCurrentTeb(), .resultPath = resultPath, .srcPath = srcPath };
    NTSTATUS status;
    TRACE( "resultPath %d, srcPath %d\n", resultPath, srcPath );
    if ((status = UNIX_CALL( glCopyPathNV, &args ))) WARN( "glCopyPathNV returned %#lx\n", status );
}

static void WINAPI glCopyTexImage1DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
{
    struct glCopyTexImage1DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .border = border };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, x %d, y %d, width %d, border %d\n", target, level, internalformat, x, y, width, border );
    if ((status = UNIX_CALL( glCopyTexImage1DEXT, &args ))) WARN( "glCopyTexImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTexImage2DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
{
    struct glCopyTexImage2DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .height = height, .border = border };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, x %d, y %d, width %d, height %d, border %d\n", target, level, internalformat, x, y, width, height, border );
    if ((status = UNIX_CALL( glCopyTexImage2DEXT, &args ))) WARN( "glCopyTexImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
{
    struct glCopyTexSubImage1DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, x %d, y %d, width %d\n", target, level, xoffset, x, y, width );
    if ((status = UNIX_CALL( glCopyTexSubImage1DEXT, &args ))) WARN( "glCopyTexSubImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyTexSubImage2DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, x %d, y %d, width %d, height %d\n", target, level, xoffset, yoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyTexSubImage2DEXT, &args ))) WARN( "glCopyTexSubImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyTexSubImage3D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, zoffset %d, x %d, y %d, width %d, height %d\n", target, level, xoffset, yoffset, zoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyTexSubImage3D, &args ))) WARN( "glCopyTexSubImage3D returned %#lx\n", status );
}

static void WINAPI glCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyTexSubImage3DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, zoffset %d, x %d, y %d, width %d, height %d\n", target, level, xoffset, yoffset, zoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyTexSubImage3DEXT, &args ))) WARN( "glCopyTexSubImage3DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
{
    struct glCopyTextureImage1DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .border = border };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, internalformat %d, x %d, y %d, width %d, border %d\n", texture, target, level, internalformat, x, y, width, border );
    if ((status = UNIX_CALL( glCopyTextureImage1DEXT, &args ))) WARN( "glCopyTextureImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
{
    struct glCopyTextureImage2DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .height = height, .border = border };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, internalformat %d, x %d, y %d, width %d, height %d, border %d\n", texture, target, level, internalformat, x, y, width, height, border );
    if ((status = UNIX_CALL( glCopyTextureImage2DEXT, &args ))) WARN( "glCopyTextureImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
{
    struct glCopyTextureSubImage1D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, x %d, y %d, width %d\n", texture, level, xoffset, x, y, width );
    if ((status = UNIX_CALL( glCopyTextureSubImage1D, &args ))) WARN( "glCopyTextureSubImage1D returned %#lx\n", status );
}

static void WINAPI glCopyTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
{
    struct glCopyTextureSubImage1DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .x = x, .y = y, .width = width };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, x %d, y %d, width %d\n", texture, target, level, xoffset, x, y, width );
    if ((status = UNIX_CALL( glCopyTextureSubImage1DEXT, &args ))) WARN( "glCopyTextureSubImage1DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyTextureSubImage2D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, x %d, y %d, width %d, height %d\n", texture, level, xoffset, yoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyTextureSubImage2D, &args ))) WARN( "glCopyTextureSubImage2D returned %#lx\n", status );
}

static void WINAPI glCopyTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyTextureSubImage2DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, yoffset %d, x %d, y %d, width %d, height %d\n", texture, target, level, xoffset, yoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyTextureSubImage2DEXT, &args ))) WARN( "glCopyTextureSubImage2DEXT returned %#lx\n", status );
}

static void WINAPI glCopyTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyTextureSubImage3D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, zoffset %d, x %d, y %d, width %d, height %d\n", texture, level, xoffset, yoffset, zoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyTextureSubImage3D, &args ))) WARN( "glCopyTextureSubImage3D returned %#lx\n", status );
}

static void WINAPI glCopyTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glCopyTextureSubImage3DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, yoffset %d, zoffset %d, x %d, y %d, width %d, height %d\n", texture, target, level, xoffset, yoffset, zoffset, x, y, width, height );
    if ((status = UNIX_CALL( glCopyTextureSubImage3DEXT, &args ))) WARN( "glCopyTextureSubImage3DEXT returned %#lx\n", status );
}

static void WINAPI glCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues )
{
    struct glCoverFillPathInstancedNV_params args = { .teb = NtCurrentTeb(), .numPaths = numPaths, .pathNameType = pathNameType, .paths = paths, .pathBase = pathBase, .coverMode = coverMode, .transformType = transformType, .transformValues = transformValues };
    NTSTATUS status;
    TRACE( "numPaths %d, pathNameType %d, paths %p, pathBase %d, coverMode %d, transformType %d, transformValues %p\n", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues );
    if ((status = UNIX_CALL( glCoverFillPathInstancedNV, &args ))) WARN( "glCoverFillPathInstancedNV returned %#lx\n", status );
}

static void WINAPI glCoverFillPathNV( GLuint path, GLenum coverMode )
{
    struct glCoverFillPathNV_params args = { .teb = NtCurrentTeb(), .path = path, .coverMode = coverMode };
    NTSTATUS status;
    TRACE( "path %d, coverMode %d\n", path, coverMode );
    if ((status = UNIX_CALL( glCoverFillPathNV, &args ))) WARN( "glCoverFillPathNV returned %#lx\n", status );
}

static void WINAPI glCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues )
{
    struct glCoverStrokePathInstancedNV_params args = { .teb = NtCurrentTeb(), .numPaths = numPaths, .pathNameType = pathNameType, .paths = paths, .pathBase = pathBase, .coverMode = coverMode, .transformType = transformType, .transformValues = transformValues };
    NTSTATUS status;
    TRACE( "numPaths %d, pathNameType %d, paths %p, pathBase %d, coverMode %d, transformType %d, transformValues %p\n", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues );
    if ((status = UNIX_CALL( glCoverStrokePathInstancedNV, &args ))) WARN( "glCoverStrokePathInstancedNV returned %#lx\n", status );
}

static void WINAPI glCoverStrokePathNV( GLuint path, GLenum coverMode )
{
    struct glCoverStrokePathNV_params args = { .teb = NtCurrentTeb(), .path = path, .coverMode = coverMode };
    NTSTATUS status;
    TRACE( "path %d, coverMode %d\n", path, coverMode );
    if ((status = UNIX_CALL( glCoverStrokePathNV, &args ))) WARN( "glCoverStrokePathNV returned %#lx\n", status );
}

static void WINAPI glCoverageModulationNV( GLenum components )
{
    struct glCoverageModulationNV_params args = { .teb = NtCurrentTeb(), .components = components };
    NTSTATUS status;
    TRACE( "components %d\n", components );
    if ((status = UNIX_CALL( glCoverageModulationNV, &args ))) WARN( "glCoverageModulationNV returned %#lx\n", status );
}

static void WINAPI glCoverageModulationTableNV( GLsizei n, const GLfloat *v )
{
    struct glCoverageModulationTableNV_params args = { .teb = NtCurrentTeb(), .n = n, .v = v };
    NTSTATUS status;
    TRACE( "n %d, v %p\n", n, v );
    if ((status = UNIX_CALL( glCoverageModulationTableNV, &args ))) WARN( "glCoverageModulationTableNV returned %#lx\n", status );
}

static void WINAPI glCreateBuffers( GLsizei n, GLuint *buffers )
{
    struct glCreateBuffers_params args = { .teb = NtCurrentTeb(), .n = n, .buffers = buffers };
    NTSTATUS status;
    TRACE( "n %d, buffers %p\n", n, buffers );
    if ((status = UNIX_CALL( glCreateBuffers, &args ))) WARN( "glCreateBuffers returned %#lx\n", status );
}

static void WINAPI glCreateCommandListsNV( GLsizei n, GLuint *lists )
{
    struct glCreateCommandListsNV_params args = { .teb = NtCurrentTeb(), .n = n, .lists = lists };
    NTSTATUS status;
    TRACE( "n %d, lists %p\n", n, lists );
    if ((status = UNIX_CALL( glCreateCommandListsNV, &args ))) WARN( "glCreateCommandListsNV returned %#lx\n", status );
}

static void WINAPI glCreateFramebuffers( GLsizei n, GLuint *framebuffers )
{
    struct glCreateFramebuffers_params args = { .teb = NtCurrentTeb(), .n = n, .framebuffers = framebuffers };
    NTSTATUS status;
    TRACE( "n %d, framebuffers %p\n", n, framebuffers );
    if ((status = UNIX_CALL( glCreateFramebuffers, &args ))) WARN( "glCreateFramebuffers returned %#lx\n", status );
}

static void WINAPI glCreateMemoryObjectsEXT( GLsizei n, GLuint *memoryObjects )
{
    struct glCreateMemoryObjectsEXT_params args = { .teb = NtCurrentTeb(), .n = n, .memoryObjects = memoryObjects };
    NTSTATUS status;
    TRACE( "n %d, memoryObjects %p\n", n, memoryObjects );
    if ((status = UNIX_CALL( glCreateMemoryObjectsEXT, &args ))) WARN( "glCreateMemoryObjectsEXT returned %#lx\n", status );
}

static void WINAPI glCreatePerfQueryINTEL( GLuint queryId, GLuint *queryHandle )
{
    struct glCreatePerfQueryINTEL_params args = { .teb = NtCurrentTeb(), .queryId = queryId, .queryHandle = queryHandle };
    NTSTATUS status;
    TRACE( "queryId %d, queryHandle %p\n", queryId, queryHandle );
    if ((status = UNIX_CALL( glCreatePerfQueryINTEL, &args ))) WARN( "glCreatePerfQueryINTEL returned %#lx\n", status );
}

static GLuint WINAPI glCreateProgram(void)
{
    struct glCreateProgram_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glCreateProgram, &args ))) WARN( "glCreateProgram returned %#lx\n", status );
    return args.ret;
}

static GLhandleARB WINAPI glCreateProgramObjectARB(void)
{
    struct glCreateProgramObjectARB_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glCreateProgramObjectARB, &args ))) WARN( "glCreateProgramObjectARB returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glCreateProgramPipelines( GLsizei n, GLuint *pipelines )
{
    struct glCreateProgramPipelines_params args = { .teb = NtCurrentTeb(), .n = n, .pipelines = pipelines };
    NTSTATUS status;
    TRACE( "n %d, pipelines %p\n", n, pipelines );
    if ((status = UNIX_CALL( glCreateProgramPipelines, &args ))) WARN( "glCreateProgramPipelines returned %#lx\n", status );
}

static GLuint WINAPI glCreateProgressFenceNVX(void)
{
    struct glCreateProgressFenceNVX_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glCreateProgressFenceNVX, &args ))) WARN( "glCreateProgressFenceNVX returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glCreateQueries( GLenum target, GLsizei n, GLuint *ids )
{
    struct glCreateQueries_params args = { .teb = NtCurrentTeb(), .target = target, .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "target %d, n %d, ids %p\n", target, n, ids );
    if ((status = UNIX_CALL( glCreateQueries, &args ))) WARN( "glCreateQueries returned %#lx\n", status );
}

static void WINAPI glCreateRenderbuffers( GLsizei n, GLuint *renderbuffers )
{
    struct glCreateRenderbuffers_params args = { .teb = NtCurrentTeb(), .n = n, .renderbuffers = renderbuffers };
    NTSTATUS status;
    TRACE( "n %d, renderbuffers %p\n", n, renderbuffers );
    if ((status = UNIX_CALL( glCreateRenderbuffers, &args ))) WARN( "glCreateRenderbuffers returned %#lx\n", status );
}

static void WINAPI glCreateSamplers( GLsizei n, GLuint *samplers )
{
    struct glCreateSamplers_params args = { .teb = NtCurrentTeb(), .n = n, .samplers = samplers };
    NTSTATUS status;
    TRACE( "n %d, samplers %p\n", n, samplers );
    if ((status = UNIX_CALL( glCreateSamplers, &args ))) WARN( "glCreateSamplers returned %#lx\n", status );
}

static GLuint WINAPI glCreateShader( GLenum type )
{
    struct glCreateShader_params args = { .teb = NtCurrentTeb(), .type = type };
    NTSTATUS status;
    TRACE( "type %d\n", type );
    if ((status = UNIX_CALL( glCreateShader, &args ))) WARN( "glCreateShader returned %#lx\n", status );
    return args.ret;
}

static GLhandleARB WINAPI glCreateShaderObjectARB( GLenum shaderType )
{
    struct glCreateShaderObjectARB_params args = { .teb = NtCurrentTeb(), .shaderType = shaderType };
    NTSTATUS status;
    TRACE( "shaderType %d\n", shaderType );
    if ((status = UNIX_CALL( glCreateShaderObjectARB, &args ))) WARN( "glCreateShaderObjectARB returned %#lx\n", status );
    return args.ret;
}

static GLuint WINAPI glCreateShaderProgramEXT( GLenum type, const GLchar *string )
{
    struct glCreateShaderProgramEXT_params args = { .teb = NtCurrentTeb(), .type = type, .string = string };
    NTSTATUS status;
    TRACE( "type %d, string %p\n", type, string );
    if ((status = UNIX_CALL( glCreateShaderProgramEXT, &args ))) WARN( "glCreateShaderProgramEXT returned %#lx\n", status );
    return args.ret;
}

static GLuint WINAPI glCreateShaderProgramv( GLenum type, GLsizei count, const GLchar *const*strings )
{
    struct glCreateShaderProgramv_params args = { .teb = NtCurrentTeb(), .type = type, .count = count, .strings = strings };
    NTSTATUS status;
    TRACE( "type %d, count %d, strings %p\n", type, count, strings );
    if ((status = UNIX_CALL( glCreateShaderProgramv, &args ))) WARN( "glCreateShaderProgramv returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glCreateStatesNV( GLsizei n, GLuint *states )
{
    struct glCreateStatesNV_params args = { .teb = NtCurrentTeb(), .n = n, .states = states };
    NTSTATUS status;
    TRACE( "n %d, states %p\n", n, states );
    if ((status = UNIX_CALL( glCreateStatesNV, &args ))) WARN( "glCreateStatesNV returned %#lx\n", status );
}

static GLsync WINAPI glCreateSyncFromCLeventARB( struct _cl_context *context, struct _cl_event *event, GLbitfield flags )
{
    struct glCreateSyncFromCLeventARB_params args = { .teb = NtCurrentTeb(), .context = context, .event = event, .flags = flags };
    NTSTATUS status;
    TRACE( "context %p, event %p, flags %d\n", context, event, flags );
    if ((status = UNIX_CALL( glCreateSyncFromCLeventARB, &args ))) WARN( "glCreateSyncFromCLeventARB returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glCreateTextures( GLenum target, GLsizei n, GLuint *textures )
{
    struct glCreateTextures_params args = { .teb = NtCurrentTeb(), .target = target, .n = n, .textures = textures };
    NTSTATUS status;
    TRACE( "target %d, n %d, textures %p\n", target, n, textures );
    if ((status = UNIX_CALL( glCreateTextures, &args ))) WARN( "glCreateTextures returned %#lx\n", status );
}

static void WINAPI glCreateTransformFeedbacks( GLsizei n, GLuint *ids )
{
    struct glCreateTransformFeedbacks_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glCreateTransformFeedbacks, &args ))) WARN( "glCreateTransformFeedbacks returned %#lx\n", status );
}

static void WINAPI glCreateVertexArrays( GLsizei n, GLuint *arrays )
{
    struct glCreateVertexArrays_params args = { .teb = NtCurrentTeb(), .n = n, .arrays = arrays };
    NTSTATUS status;
    TRACE( "n %d, arrays %p\n", n, arrays );
    if ((status = UNIX_CALL( glCreateVertexArrays, &args ))) WARN( "glCreateVertexArrays returned %#lx\n", status );
}

static void WINAPI glCullParameterdvEXT( GLenum pname, GLdouble *params )
{
    struct glCullParameterdvEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glCullParameterdvEXT, &args ))) WARN( "glCullParameterdvEXT returned %#lx\n", status );
}

static void WINAPI glCullParameterfvEXT( GLenum pname, GLfloat *params )
{
    struct glCullParameterfvEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glCullParameterfvEXT, &args ))) WARN( "glCullParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glCurrentPaletteMatrixARB( GLint index )
{
    struct glCurrentPaletteMatrixARB_params args = { .teb = NtCurrentTeb(), .index = index };
    NTSTATUS status;
    TRACE( "index %d\n", index );
    if ((status = UNIX_CALL( glCurrentPaletteMatrixARB, &args ))) WARN( "glCurrentPaletteMatrixARB returned %#lx\n", status );
}

static void WINAPI glDebugMessageCallback( GLDEBUGPROC callback, const void *userParam )
{
    struct glDebugMessageCallback_params args = { .teb = NtCurrentTeb(), .callback = callback, .userParam = userParam };
    NTSTATUS status;
    TRACE( "callback %p, userParam %p\n", callback, userParam );
    if ((status = UNIX_CALL( glDebugMessageCallback, &args ))) WARN( "glDebugMessageCallback returned %#lx\n", status );
}

static void WINAPI glDebugMessageCallbackAMD( GLDEBUGPROCAMD callback, void *userParam )
{
    struct glDebugMessageCallbackAMD_params args = { .teb = NtCurrentTeb(), .callback = callback, .userParam = userParam };
    NTSTATUS status;
    TRACE( "callback %p, userParam %p\n", callback, userParam );
    if ((status = UNIX_CALL( glDebugMessageCallbackAMD, &args ))) WARN( "glDebugMessageCallbackAMD returned %#lx\n", status );
}

static void WINAPI glDebugMessageCallbackARB( GLDEBUGPROCARB callback, const void *userParam )
{
    struct glDebugMessageCallbackARB_params args = { .teb = NtCurrentTeb(), .callback = callback, .userParam = userParam };
    NTSTATUS status;
    TRACE( "callback %p, userParam %p\n", callback, userParam );
    if ((status = UNIX_CALL( glDebugMessageCallbackARB, &args ))) WARN( "glDebugMessageCallbackARB returned %#lx\n", status );
}

static void WINAPI glDebugMessageControl( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled )
{
    struct glDebugMessageControl_params args = { .teb = NtCurrentTeb(), .source = source, .type = type, .severity = severity, .count = count, .ids = ids, .enabled = enabled };
    NTSTATUS status;
    TRACE( "source %d, type %d, severity %d, count %d, ids %p, enabled %d\n", source, type, severity, count, ids, enabled );
    if ((status = UNIX_CALL( glDebugMessageControl, &args ))) WARN( "glDebugMessageControl returned %#lx\n", status );
}

static void WINAPI glDebugMessageControlARB( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled )
{
    struct glDebugMessageControlARB_params args = { .teb = NtCurrentTeb(), .source = source, .type = type, .severity = severity, .count = count, .ids = ids, .enabled = enabled };
    NTSTATUS status;
    TRACE( "source %d, type %d, severity %d, count %d, ids %p, enabled %d\n", source, type, severity, count, ids, enabled );
    if ((status = UNIX_CALL( glDebugMessageControlARB, &args ))) WARN( "glDebugMessageControlARB returned %#lx\n", status );
}

static void WINAPI glDebugMessageEnableAMD( GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled )
{
    struct glDebugMessageEnableAMD_params args = { .teb = NtCurrentTeb(), .category = category, .severity = severity, .count = count, .ids = ids, .enabled = enabled };
    NTSTATUS status;
    TRACE( "category %d, severity %d, count %d, ids %p, enabled %d\n", category, severity, count, ids, enabled );
    if ((status = UNIX_CALL( glDebugMessageEnableAMD, &args ))) WARN( "glDebugMessageEnableAMD returned %#lx\n", status );
}

static void WINAPI glDebugMessageInsert( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf )
{
    struct glDebugMessageInsert_params args = { .teb = NtCurrentTeb(), .source = source, .type = type, .id = id, .severity = severity, .length = length, .buf = buf };
    NTSTATUS status;
    TRACE( "source %d, type %d, id %d, severity %d, length %d, buf %p\n", source, type, id, severity, length, buf );
    if ((status = UNIX_CALL( glDebugMessageInsert, &args ))) WARN( "glDebugMessageInsert returned %#lx\n", status );
}

static void WINAPI glDebugMessageInsertAMD( GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf )
{
    struct glDebugMessageInsertAMD_params args = { .teb = NtCurrentTeb(), .category = category, .severity = severity, .id = id, .length = length, .buf = buf };
    NTSTATUS status;
    TRACE( "category %d, severity %d, id %d, length %d, buf %p\n", category, severity, id, length, buf );
    if ((status = UNIX_CALL( glDebugMessageInsertAMD, &args ))) WARN( "glDebugMessageInsertAMD returned %#lx\n", status );
}

static void WINAPI glDebugMessageInsertARB( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf )
{
    struct glDebugMessageInsertARB_params args = { .teb = NtCurrentTeb(), .source = source, .type = type, .id = id, .severity = severity, .length = length, .buf = buf };
    NTSTATUS status;
    TRACE( "source %d, type %d, id %d, severity %d, length %d, buf %p\n", source, type, id, severity, length, buf );
    if ((status = UNIX_CALL( glDebugMessageInsertARB, &args ))) WARN( "glDebugMessageInsertARB returned %#lx\n", status );
}

static void WINAPI glDeformSGIX( GLbitfield mask )
{
    struct glDeformSGIX_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glDeformSGIX, &args ))) WARN( "glDeformSGIX returned %#lx\n", status );
}

static void WINAPI glDeformationMap3dSGIX( GLenum 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, const GLdouble *points )
{
    struct glDeformationMap3dSGIX_params args = { .teb = NtCurrentTeb(), .target = target, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .w1 = w1, .w2 = w2, .wstride = wstride, .worder = worder, .points = points };
    NTSTATUS status;
    TRACE( "target %d, u1 %f, u2 %f, ustride %d, uorder %d, v1 %f, v2 %f, vstride %d, vorder %d, w1 %f, w2 %f, wstride %d, worder %d, points %p\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
    if ((status = UNIX_CALL( glDeformationMap3dSGIX, &args ))) WARN( "glDeformationMap3dSGIX returned %#lx\n", status );
}

static void WINAPI glDeformationMap3fSGIX( GLenum 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, const GLfloat *points )
{
    struct glDeformationMap3fSGIX_params args = { .teb = NtCurrentTeb(), .target = target, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .w1 = w1, .w2 = w2, .wstride = wstride, .worder = worder, .points = points };
    NTSTATUS status;
    TRACE( "target %d, u1 %f, u2 %f, ustride %d, uorder %d, v1 %f, v2 %f, vstride %d, vorder %d, w1 %f, w2 %f, wstride %d, worder %d, points %p\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
    if ((status = UNIX_CALL( glDeformationMap3fSGIX, &args ))) WARN( "glDeformationMap3fSGIX returned %#lx\n", status );
}

static void WINAPI glDeleteAsyncMarkersSGIX( GLuint marker, GLsizei range )
{
    struct glDeleteAsyncMarkersSGIX_params args = { .teb = NtCurrentTeb(), .marker = marker, .range = range };
    NTSTATUS status;
    TRACE( "marker %d, range %d\n", marker, range );
    if ((status = UNIX_CALL( glDeleteAsyncMarkersSGIX, &args ))) WARN( "glDeleteAsyncMarkersSGIX returned %#lx\n", status );
}

static void WINAPI glDeleteBufferRegion( GLenum region )
{
    struct glDeleteBufferRegion_params args = { .teb = NtCurrentTeb(), .region = region };
    NTSTATUS status;
    TRACE( "region %d\n", region );
    if ((status = UNIX_CALL( glDeleteBufferRegion, &args ))) WARN( "glDeleteBufferRegion returned %#lx\n", status );
}

static void WINAPI glDeleteBuffers( GLsizei n, const GLuint *buffers )
{
    struct glDeleteBuffers_params args = { .teb = NtCurrentTeb(), .n = n, .buffers = buffers };
    NTSTATUS status;
    TRACE( "n %d, buffers %p\n", n, buffers );
    if ((status = UNIX_CALL( glDeleteBuffers, &args ))) WARN( "glDeleteBuffers returned %#lx\n", status );
}

static void WINAPI glDeleteBuffersARB( GLsizei n, const GLuint *buffers )
{
    struct glDeleteBuffersARB_params args = { .teb = NtCurrentTeb(), .n = n, .buffers = buffers };
    NTSTATUS status;
    TRACE( "n %d, buffers %p\n", n, buffers );
    if ((status = UNIX_CALL( glDeleteBuffersARB, &args ))) WARN( "glDeleteBuffersARB returned %#lx\n", status );
}

static void WINAPI glDeleteCommandListsNV( GLsizei n, const GLuint *lists )
{
    struct glDeleteCommandListsNV_params args = { .teb = NtCurrentTeb(), .n = n, .lists = lists };
    NTSTATUS status;
    TRACE( "n %d, lists %p\n", n, lists );
    if ((status = UNIX_CALL( glDeleteCommandListsNV, &args ))) WARN( "glDeleteCommandListsNV returned %#lx\n", status );
}

static void WINAPI glDeleteFencesAPPLE( GLsizei n, const GLuint *fences )
{
    struct glDeleteFencesAPPLE_params args = { .teb = NtCurrentTeb(), .n = n, .fences = fences };
    NTSTATUS status;
    TRACE( "n %d, fences %p\n", n, fences );
    if ((status = UNIX_CALL( glDeleteFencesAPPLE, &args ))) WARN( "glDeleteFencesAPPLE returned %#lx\n", status );
}

static void WINAPI glDeleteFencesNV( GLsizei n, const GLuint *fences )
{
    struct glDeleteFencesNV_params args = { .teb = NtCurrentTeb(), .n = n, .fences = fences };
    NTSTATUS status;
    TRACE( "n %d, fences %p\n", n, fences );
    if ((status = UNIX_CALL( glDeleteFencesNV, &args ))) WARN( "glDeleteFencesNV returned %#lx\n", status );
}

static void WINAPI glDeleteFragmentShaderATI( GLuint id )
{
    struct glDeleteFragmentShaderATI_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glDeleteFragmentShaderATI, &args ))) WARN( "glDeleteFragmentShaderATI returned %#lx\n", status );
}

static void WINAPI glDeleteFramebuffers( GLsizei n, const GLuint *framebuffers )
{
    struct glDeleteFramebuffers_params args = { .teb = NtCurrentTeb(), .n = n, .framebuffers = framebuffers };
    NTSTATUS status;
    TRACE( "n %d, framebuffers %p\n", n, framebuffers );
    if ((status = UNIX_CALL( glDeleteFramebuffers, &args ))) WARN( "glDeleteFramebuffers returned %#lx\n", status );
}

static void WINAPI glDeleteFramebuffersEXT( GLsizei n, const GLuint *framebuffers )
{
    struct glDeleteFramebuffersEXT_params args = { .teb = NtCurrentTeb(), .n = n, .framebuffers = framebuffers };
    NTSTATUS status;
    TRACE( "n %d, framebuffers %p\n", n, framebuffers );
    if ((status = UNIX_CALL( glDeleteFramebuffersEXT, &args ))) WARN( "glDeleteFramebuffersEXT returned %#lx\n", status );
}

static void WINAPI glDeleteMemoryObjectsEXT( GLsizei n, const GLuint *memoryObjects )
{
    struct glDeleteMemoryObjectsEXT_params args = { .teb = NtCurrentTeb(), .n = n, .memoryObjects = memoryObjects };
    NTSTATUS status;
    TRACE( "n %d, memoryObjects %p\n", n, memoryObjects );
    if ((status = UNIX_CALL( glDeleteMemoryObjectsEXT, &args ))) WARN( "glDeleteMemoryObjectsEXT returned %#lx\n", status );
}

static void WINAPI glDeleteNamedStringARB( GLint namelen, const GLchar *name )
{
    struct glDeleteNamedStringARB_params args = { .teb = NtCurrentTeb(), .namelen = namelen, .name = name };
    NTSTATUS status;
    TRACE( "namelen %d, name %p\n", namelen, name );
    if ((status = UNIX_CALL( glDeleteNamedStringARB, &args ))) WARN( "glDeleteNamedStringARB returned %#lx\n", status );
}

static void WINAPI glDeleteNamesAMD( GLenum identifier, GLuint num, const GLuint *names )
{
    struct glDeleteNamesAMD_params args = { .teb = NtCurrentTeb(), .identifier = identifier, .num = num, .names = names };
    NTSTATUS status;
    TRACE( "identifier %d, num %d, names %p\n", identifier, num, names );
    if ((status = UNIX_CALL( glDeleteNamesAMD, &args ))) WARN( "glDeleteNamesAMD returned %#lx\n", status );
}

static void WINAPI glDeleteObjectARB( GLhandleARB obj )
{
    struct glDeleteObjectARB_params args = { .teb = NtCurrentTeb(), .obj = obj };
    NTSTATUS status;
    TRACE( "obj %d\n", obj );
    if ((status = UNIX_CALL( glDeleteObjectARB, &args ))) WARN( "glDeleteObjectARB returned %#lx\n", status );
}

static void WINAPI glDeleteObjectBufferATI( GLuint buffer )
{
    struct glDeleteObjectBufferATI_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glDeleteObjectBufferATI, &args ))) WARN( "glDeleteObjectBufferATI returned %#lx\n", status );
}

static void WINAPI glDeleteOcclusionQueriesNV( GLsizei n, const GLuint *ids )
{
    struct glDeleteOcclusionQueriesNV_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glDeleteOcclusionQueriesNV, &args ))) WARN( "glDeleteOcclusionQueriesNV returned %#lx\n", status );
}

static void WINAPI glDeletePathsNV( GLuint path, GLsizei range )
{
    struct glDeletePathsNV_params args = { .teb = NtCurrentTeb(), .path = path, .range = range };
    NTSTATUS status;
    TRACE( "path %d, range %d\n", path, range );
    if ((status = UNIX_CALL( glDeletePathsNV, &args ))) WARN( "glDeletePathsNV returned %#lx\n", status );
}

static void WINAPI glDeletePerfMonitorsAMD( GLsizei n, GLuint *monitors )
{
    struct glDeletePerfMonitorsAMD_params args = { .teb = NtCurrentTeb(), .n = n, .monitors = monitors };
    NTSTATUS status;
    TRACE( "n %d, monitors %p\n", n, monitors );
    if ((status = UNIX_CALL( glDeletePerfMonitorsAMD, &args ))) WARN( "glDeletePerfMonitorsAMD returned %#lx\n", status );
}

static void WINAPI glDeletePerfQueryINTEL( GLuint queryHandle )
{
    struct glDeletePerfQueryINTEL_params args = { .teb = NtCurrentTeb(), .queryHandle = queryHandle };
    NTSTATUS status;
    TRACE( "queryHandle %d\n", queryHandle );
    if ((status = UNIX_CALL( glDeletePerfQueryINTEL, &args ))) WARN( "glDeletePerfQueryINTEL returned %#lx\n", status );
}

static void WINAPI glDeleteProgram( GLuint program )
{
    struct glDeleteProgram_params args = { .teb = NtCurrentTeb(), .program = program };
    NTSTATUS status;
    TRACE( "program %d\n", program );
    if ((status = UNIX_CALL( glDeleteProgram, &args ))) WARN( "glDeleteProgram returned %#lx\n", status );
}

static void WINAPI glDeleteProgramPipelines( GLsizei n, const GLuint *pipelines )
{
    struct glDeleteProgramPipelines_params args = { .teb = NtCurrentTeb(), .n = n, .pipelines = pipelines };
    NTSTATUS status;
    TRACE( "n %d, pipelines %p\n", n, pipelines );
    if ((status = UNIX_CALL( glDeleteProgramPipelines, &args ))) WARN( "glDeleteProgramPipelines returned %#lx\n", status );
}

static void WINAPI glDeleteProgramsARB( GLsizei n, const GLuint *programs )
{
    struct glDeleteProgramsARB_params args = { .teb = NtCurrentTeb(), .n = n, .programs = programs };
    NTSTATUS status;
    TRACE( "n %d, programs %p\n", n, programs );
    if ((status = UNIX_CALL( glDeleteProgramsARB, &args ))) WARN( "glDeleteProgramsARB returned %#lx\n", status );
}

static void WINAPI glDeleteProgramsNV( GLsizei n, const GLuint *programs )
{
    struct glDeleteProgramsNV_params args = { .teb = NtCurrentTeb(), .n = n, .programs = programs };
    NTSTATUS status;
    TRACE( "n %d, programs %p\n", n, programs );
    if ((status = UNIX_CALL( glDeleteProgramsNV, &args ))) WARN( "glDeleteProgramsNV returned %#lx\n", status );
}

static void WINAPI glDeleteQueries( GLsizei n, const GLuint *ids )
{
    struct glDeleteQueries_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glDeleteQueries, &args ))) WARN( "glDeleteQueries returned %#lx\n", status );
}

static void WINAPI glDeleteQueriesARB( GLsizei n, const GLuint *ids )
{
    struct glDeleteQueriesARB_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glDeleteQueriesARB, &args ))) WARN( "glDeleteQueriesARB returned %#lx\n", status );
}

static void WINAPI glDeleteQueryResourceTagNV( GLsizei n, const GLint *tagIds )
{
    struct glDeleteQueryResourceTagNV_params args = { .teb = NtCurrentTeb(), .n = n, .tagIds = tagIds };
    NTSTATUS status;
    TRACE( "n %d, tagIds %p\n", n, tagIds );
    if ((status = UNIX_CALL( glDeleteQueryResourceTagNV, &args ))) WARN( "glDeleteQueryResourceTagNV returned %#lx\n", status );
}

static void WINAPI glDeleteRenderbuffers( GLsizei n, const GLuint *renderbuffers )
{
    struct glDeleteRenderbuffers_params args = { .teb = NtCurrentTeb(), .n = n, .renderbuffers = renderbuffers };
    NTSTATUS status;
    TRACE( "n %d, renderbuffers %p\n", n, renderbuffers );
    if ((status = UNIX_CALL( glDeleteRenderbuffers, &args ))) WARN( "glDeleteRenderbuffers returned %#lx\n", status );
}

static void WINAPI glDeleteRenderbuffersEXT( GLsizei n, const GLuint *renderbuffers )
{
    struct glDeleteRenderbuffersEXT_params args = { .teb = NtCurrentTeb(), .n = n, .renderbuffers = renderbuffers };
    NTSTATUS status;
    TRACE( "n %d, renderbuffers %p\n", n, renderbuffers );
    if ((status = UNIX_CALL( glDeleteRenderbuffersEXT, &args ))) WARN( "glDeleteRenderbuffersEXT returned %#lx\n", status );
}

static void WINAPI glDeleteSamplers( GLsizei count, const GLuint *samplers )
{
    struct glDeleteSamplers_params args = { .teb = NtCurrentTeb(), .count = count, .samplers = samplers };
    NTSTATUS status;
    TRACE( "count %d, samplers %p\n", count, samplers );
    if ((status = UNIX_CALL( glDeleteSamplers, &args ))) WARN( "glDeleteSamplers returned %#lx\n", status );
}

static void WINAPI glDeleteSemaphoresEXT( GLsizei n, const GLuint *semaphores )
{
    struct glDeleteSemaphoresEXT_params args = { .teb = NtCurrentTeb(), .n = n, .semaphores = semaphores };
    NTSTATUS status;
    TRACE( "n %d, semaphores %p\n", n, semaphores );
    if ((status = UNIX_CALL( glDeleteSemaphoresEXT, &args ))) WARN( "glDeleteSemaphoresEXT returned %#lx\n", status );
}

static void WINAPI glDeleteShader( GLuint shader )
{
    struct glDeleteShader_params args = { .teb = NtCurrentTeb(), .shader = shader };
    NTSTATUS status;
    TRACE( "shader %d\n", shader );
    if ((status = UNIX_CALL( glDeleteShader, &args ))) WARN( "glDeleteShader returned %#lx\n", status );
}

static void WINAPI glDeleteStatesNV( GLsizei n, const GLuint *states )
{
    struct glDeleteStatesNV_params args = { .teb = NtCurrentTeb(), .n = n, .states = states };
    NTSTATUS status;
    TRACE( "n %d, states %p\n", n, states );
    if ((status = UNIX_CALL( glDeleteStatesNV, &args ))) WARN( "glDeleteStatesNV returned %#lx\n", status );
}

static void WINAPI glDeleteSync( GLsync sync )
{
    struct glDeleteSync_params args = { .teb = NtCurrentTeb(), .sync = sync };
    NTSTATUS status;
    TRACE( "sync %p\n", sync );
    if ((status = UNIX_CALL( glDeleteSync, &args ))) WARN( "glDeleteSync returned %#lx\n", status );
}

static void WINAPI glDeleteTexturesEXT( GLsizei n, const GLuint *textures )
{
    struct glDeleteTexturesEXT_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures };
    NTSTATUS status;
    TRACE( "n %d, textures %p\n", n, textures );
    if ((status = UNIX_CALL( glDeleteTexturesEXT, &args ))) WARN( "glDeleteTexturesEXT returned %#lx\n", status );
}

static void WINAPI glDeleteTransformFeedbacks( GLsizei n, const GLuint *ids )
{
    struct glDeleteTransformFeedbacks_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glDeleteTransformFeedbacks, &args ))) WARN( "glDeleteTransformFeedbacks returned %#lx\n", status );
}

static void WINAPI glDeleteTransformFeedbacksNV( GLsizei n, const GLuint *ids )
{
    struct glDeleteTransformFeedbacksNV_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glDeleteTransformFeedbacksNV, &args ))) WARN( "glDeleteTransformFeedbacksNV returned %#lx\n", status );
}

static void WINAPI glDeleteVertexArrays( GLsizei n, const GLuint *arrays )
{
    struct glDeleteVertexArrays_params args = { .teb = NtCurrentTeb(), .n = n, .arrays = arrays };
    NTSTATUS status;
    TRACE( "n %d, arrays %p\n", n, arrays );
    if ((status = UNIX_CALL( glDeleteVertexArrays, &args ))) WARN( "glDeleteVertexArrays returned %#lx\n", status );
}

static void WINAPI glDeleteVertexArraysAPPLE( GLsizei n, const GLuint *arrays )
{
    struct glDeleteVertexArraysAPPLE_params args = { .teb = NtCurrentTeb(), .n = n, .arrays = arrays };
    NTSTATUS status;
    TRACE( "n %d, arrays %p\n", n, arrays );
    if ((status = UNIX_CALL( glDeleteVertexArraysAPPLE, &args ))) WARN( "glDeleteVertexArraysAPPLE returned %#lx\n", status );
}

static void WINAPI glDeleteVertexShaderEXT( GLuint id )
{
    struct glDeleteVertexShaderEXT_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glDeleteVertexShaderEXT, &args ))) WARN( "glDeleteVertexShaderEXT returned %#lx\n", status );
}

static void WINAPI glDepthBoundsEXT( GLclampd zmin, GLclampd zmax )
{
    struct glDepthBoundsEXT_params args = { .teb = NtCurrentTeb(), .zmin = zmin, .zmax = zmax };
    NTSTATUS status;
    TRACE( "zmin %f, zmax %f\n", zmin, zmax );
    if ((status = UNIX_CALL( glDepthBoundsEXT, &args ))) WARN( "glDepthBoundsEXT returned %#lx\n", status );
}

static void WINAPI glDepthBoundsdNV( GLdouble zmin, GLdouble zmax )
{
    struct glDepthBoundsdNV_params args = { .teb = NtCurrentTeb(), .zmin = zmin, .zmax = zmax };
    NTSTATUS status;
    TRACE( "zmin %f, zmax %f\n", zmin, zmax );
    if ((status = UNIX_CALL( glDepthBoundsdNV, &args ))) WARN( "glDepthBoundsdNV returned %#lx\n", status );
}

static void WINAPI glDepthRangeArraydvNV( GLuint first, GLsizei count, const GLdouble *v )
{
    struct glDepthRangeArraydvNV_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "first %d, count %d, v %p\n", first, count, v );
    if ((status = UNIX_CALL( glDepthRangeArraydvNV, &args ))) WARN( "glDepthRangeArraydvNV returned %#lx\n", status );
}

static void WINAPI glDepthRangeArrayv( GLuint first, GLsizei count, const GLdouble *v )
{
    struct glDepthRangeArrayv_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "first %d, count %d, v %p\n", first, count, v );
    if ((status = UNIX_CALL( glDepthRangeArrayv, &args ))) WARN( "glDepthRangeArrayv returned %#lx\n", status );
}

static void WINAPI glDepthRangeIndexed( GLuint index, GLdouble n, GLdouble f )
{
    struct glDepthRangeIndexed_params args = { .teb = NtCurrentTeb(), .index = index, .n = n, .f = f };
    NTSTATUS status;
    TRACE( "index %d, n %f, f %f\n", index, n, f );
    if ((status = UNIX_CALL( glDepthRangeIndexed, &args ))) WARN( "glDepthRangeIndexed returned %#lx\n", status );
}

static void WINAPI glDepthRangeIndexeddNV( GLuint index, GLdouble n, GLdouble f )
{
    struct glDepthRangeIndexeddNV_params args = { .teb = NtCurrentTeb(), .index = index, .n = n, .f = f };
    NTSTATUS status;
    TRACE( "index %d, n %f, f %f\n", index, n, f );
    if ((status = UNIX_CALL( glDepthRangeIndexeddNV, &args ))) WARN( "glDepthRangeIndexeddNV returned %#lx\n", status );
}

static void WINAPI glDepthRangedNV( GLdouble zNear, GLdouble zFar )
{
    struct glDepthRangedNV_params args = { .teb = NtCurrentTeb(), .zNear = zNear, .zFar = zFar };
    NTSTATUS status;
    TRACE( "zNear %f, zFar %f\n", zNear, zFar );
    if ((status = UNIX_CALL( glDepthRangedNV, &args ))) WARN( "glDepthRangedNV returned %#lx\n", status );
}

static void WINAPI glDepthRangef( GLfloat n, GLfloat f )
{
    struct glDepthRangef_params args = { .teb = NtCurrentTeb(), .n = n, .f = f };
    NTSTATUS status;
    TRACE( "n %f, f %f\n", n, f );
    if ((status = UNIX_CALL( glDepthRangef, &args ))) WARN( "glDepthRangef returned %#lx\n", status );
}

static void WINAPI glDepthRangefOES( GLclampf n, GLclampf f )
{
    struct glDepthRangefOES_params args = { .teb = NtCurrentTeb(), .n = n, .f = f };
    NTSTATUS status;
    TRACE( "n %f, f %f\n", n, f );
    if ((status = UNIX_CALL( glDepthRangefOES, &args ))) WARN( "glDepthRangefOES returned %#lx\n", status );
}

static void WINAPI glDepthRangexOES( GLfixed n, GLfixed f )
{
    struct glDepthRangexOES_params args = { .teb = NtCurrentTeb(), .n = n, .f = f };
    NTSTATUS status;
    TRACE( "n %d, f %d\n", n, f );
    if ((status = UNIX_CALL( glDepthRangexOES, &args ))) WARN( "glDepthRangexOES returned %#lx\n", status );
}

static void WINAPI glDetachObjectARB( GLhandleARB containerObj, GLhandleARB attachedObj )
{
    struct glDetachObjectARB_params args = { .teb = NtCurrentTeb(), .containerObj = containerObj, .attachedObj = attachedObj };
    NTSTATUS status;
    TRACE( "containerObj %d, attachedObj %d\n", containerObj, attachedObj );
    if ((status = UNIX_CALL( glDetachObjectARB, &args ))) WARN( "glDetachObjectARB returned %#lx\n", status );
}

static void WINAPI glDetachShader( GLuint program, GLuint shader )
{
    struct glDetachShader_params args = { .teb = NtCurrentTeb(), .program = program, .shader = shader };
    NTSTATUS status;
    TRACE( "program %d, shader %d\n", program, shader );
    if ((status = UNIX_CALL( glDetachShader, &args ))) WARN( "glDetachShader returned %#lx\n", status );
}

static void WINAPI glDetailTexFuncSGIS( GLenum target, GLsizei n, const GLfloat *points )
{
    struct glDetailTexFuncSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .n = n, .points = points };
    NTSTATUS status;
    TRACE( "target %d, n %d, points %p\n", target, n, points );
    if ((status = UNIX_CALL( glDetailTexFuncSGIS, &args ))) WARN( "glDetailTexFuncSGIS returned %#lx\n", status );
}

static void WINAPI glDisableClientStateIndexedEXT( GLenum array, GLuint index )
{
    struct glDisableClientStateIndexedEXT_params args = { .teb = NtCurrentTeb(), .array = array, .index = index };
    NTSTATUS status;
    TRACE( "array %d, index %d\n", array, index );
    if ((status = UNIX_CALL( glDisableClientStateIndexedEXT, &args ))) WARN( "glDisableClientStateIndexedEXT returned %#lx\n", status );
}

static void WINAPI glDisableClientStateiEXT( GLenum array, GLuint index )
{
    struct glDisableClientStateiEXT_params args = { .teb = NtCurrentTeb(), .array = array, .index = index };
    NTSTATUS status;
    TRACE( "array %d, index %d\n", array, index );
    if ((status = UNIX_CALL( glDisableClientStateiEXT, &args ))) WARN( "glDisableClientStateiEXT returned %#lx\n", status );
}

static void WINAPI glDisableIndexedEXT( GLenum target, GLuint index )
{
    struct glDisableIndexedEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index };
    NTSTATUS status;
    TRACE( "target %d, index %d\n", target, index );
    if ((status = UNIX_CALL( glDisableIndexedEXT, &args ))) WARN( "glDisableIndexedEXT returned %#lx\n", status );
}

static void WINAPI glDisableVariantClientStateEXT( GLuint id )
{
    struct glDisableVariantClientStateEXT_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glDisableVariantClientStateEXT, &args ))) WARN( "glDisableVariantClientStateEXT returned %#lx\n", status );
}

static void WINAPI glDisableVertexArrayAttrib( GLuint vaobj, GLuint index )
{
    struct glDisableVertexArrayAttrib_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d\n", vaobj, index );
    if ((status = UNIX_CALL( glDisableVertexArrayAttrib, &args ))) WARN( "glDisableVertexArrayAttrib returned %#lx\n", status );
}

static void WINAPI glDisableVertexArrayAttribEXT( GLuint vaobj, GLuint index )
{
    struct glDisableVertexArrayAttribEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d\n", vaobj, index );
    if ((status = UNIX_CALL( glDisableVertexArrayAttribEXT, &args ))) WARN( "glDisableVertexArrayAttribEXT returned %#lx\n", status );
}

static void WINAPI glDisableVertexArrayEXT( GLuint vaobj, GLenum array )
{
    struct glDisableVertexArrayEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .array = array };
    NTSTATUS status;
    TRACE( "vaobj %d, array %d\n", vaobj, array );
    if ((status = UNIX_CALL( glDisableVertexArrayEXT, &args ))) WARN( "glDisableVertexArrayEXT returned %#lx\n", status );
}

static void WINAPI glDisableVertexAttribAPPLE( GLuint index, GLenum pname )
{
    struct glDisableVertexAttribAPPLE_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname };
    NTSTATUS status;
    TRACE( "index %d, pname %d\n", index, pname );
    if ((status = UNIX_CALL( glDisableVertexAttribAPPLE, &args ))) WARN( "glDisableVertexAttribAPPLE returned %#lx\n", status );
}

static void WINAPI glDisableVertexAttribArray( GLuint index )
{
    struct glDisableVertexAttribArray_params args = { .teb = NtCurrentTeb(), .index = index };
    NTSTATUS status;
    TRACE( "index %d\n", index );
    if ((status = UNIX_CALL( glDisableVertexAttribArray, &args ))) WARN( "glDisableVertexAttribArray returned %#lx\n", status );
}

static void WINAPI glDisableVertexAttribArrayARB( GLuint index )
{
    struct glDisableVertexAttribArrayARB_params args = { .teb = NtCurrentTeb(), .index = index };
    NTSTATUS status;
    TRACE( "index %d\n", index );
    if ((status = UNIX_CALL( glDisableVertexAttribArrayARB, &args ))) WARN( "glDisableVertexAttribArrayARB returned %#lx\n", status );
}

static void WINAPI glDisablei( GLenum target, GLuint index )
{
    struct glDisablei_params args = { .teb = NtCurrentTeb(), .target = target, .index = index };
    NTSTATUS status;
    TRACE( "target %d, index %d\n", target, index );
    if ((status = UNIX_CALL( glDisablei, &args ))) WARN( "glDisablei returned %#lx\n", status );
}

static void WINAPI glDispatchCompute( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z )
{
    struct glDispatchCompute_params args = { .teb = NtCurrentTeb(), .num_groups_x = num_groups_x, .num_groups_y = num_groups_y, .num_groups_z = num_groups_z };
    NTSTATUS status;
    TRACE( "num_groups_x %d, num_groups_y %d, num_groups_z %d\n", num_groups_x, num_groups_y, num_groups_z );
    if ((status = UNIX_CALL( glDispatchCompute, &args ))) WARN( "glDispatchCompute returned %#lx\n", status );
}

static void WINAPI glDispatchComputeGroupSizeARB( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z )
{
    struct glDispatchComputeGroupSizeARB_params args = { .teb = NtCurrentTeb(), .num_groups_x = num_groups_x, .num_groups_y = num_groups_y, .num_groups_z = num_groups_z, .group_size_x = group_size_x, .group_size_y = group_size_y, .group_size_z = group_size_z };
    NTSTATUS status;
    TRACE( "num_groups_x %d, num_groups_y %d, num_groups_z %d, group_size_x %d, group_size_y %d, group_size_z %d\n", num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z );
    if ((status = UNIX_CALL( glDispatchComputeGroupSizeARB, &args ))) WARN( "glDispatchComputeGroupSizeARB returned %#lx\n", status );
}

static void WINAPI glDispatchComputeIndirect( GLintptr indirect )
{
    struct glDispatchComputeIndirect_params args = { .teb = NtCurrentTeb(), .indirect = indirect };
    NTSTATUS status;
    TRACE( "indirect %Id\n", indirect );
    if ((status = UNIX_CALL( glDispatchComputeIndirect, &args ))) WARN( "glDispatchComputeIndirect returned %#lx\n", status );
}

static void WINAPI glDrawArraysEXT( GLenum mode, GLint first, GLsizei count )
{
    struct glDrawArraysEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count };
    NTSTATUS status;
    TRACE( "mode %d, first %d, count %d\n", mode, first, count );
    if ((status = UNIX_CALL( glDrawArraysEXT, &args ))) WARN( "glDrawArraysEXT returned %#lx\n", status );
}

static void WINAPI glDrawArraysIndirect( GLenum mode, const void *indirect )
{
    struct glDrawArraysIndirect_params args = { .teb = NtCurrentTeb(), .mode = mode, .indirect = indirect };
    NTSTATUS status;
    TRACE( "mode %d, indirect %p\n", mode, indirect );
    if ((status = UNIX_CALL( glDrawArraysIndirect, &args ))) WARN( "glDrawArraysIndirect returned %#lx\n", status );
}

static void WINAPI glDrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instancecount )
{
    struct glDrawArraysInstanced_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count, .instancecount = instancecount };
    NTSTATUS status;
    TRACE( "mode %d, first %d, count %d, instancecount %d\n", mode, first, count, instancecount );
    if ((status = UNIX_CALL( glDrawArraysInstanced, &args ))) WARN( "glDrawArraysInstanced returned %#lx\n", status );
}

static void WINAPI glDrawArraysInstancedARB( GLenum mode, GLint first, GLsizei count, GLsizei primcount )
{
    struct glDrawArraysInstancedARB_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count, .primcount = primcount };
    NTSTATUS status;
    TRACE( "mode %d, first %d, count %d, primcount %d\n", mode, first, count, primcount );
    if ((status = UNIX_CALL( glDrawArraysInstancedARB, &args ))) WARN( "glDrawArraysInstancedARB returned %#lx\n", status );
}

static void WINAPI glDrawArraysInstancedBaseInstance( GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance )
{
    struct glDrawArraysInstancedBaseInstance_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count, .instancecount = instancecount, .baseinstance = baseinstance };
    NTSTATUS status;
    TRACE( "mode %d, first %d, count %d, instancecount %d, baseinstance %d\n", mode, first, count, instancecount, baseinstance );
    if ((status = UNIX_CALL( glDrawArraysInstancedBaseInstance, &args ))) WARN( "glDrawArraysInstancedBaseInstance returned %#lx\n", status );
}

static void WINAPI glDrawArraysInstancedEXT( GLenum mode, GLint start, GLsizei count, GLsizei primcount )
{
    struct glDrawArraysInstancedEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .start = start, .count = count, .primcount = primcount };
    NTSTATUS status;
    TRACE( "mode %d, start %d, count %d, primcount %d\n", mode, start, count, primcount );
    if ((status = UNIX_CALL( glDrawArraysInstancedEXT, &args ))) WARN( "glDrawArraysInstancedEXT returned %#lx\n", status );
}

static void WINAPI glDrawBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest )
{
    struct glDrawBufferRegion_params args = { .teb = NtCurrentTeb(), .region = region, .x = x, .y = y, .width = width, .height = height, .xDest = xDest, .yDest = yDest };
    NTSTATUS status;
    TRACE( "region %d, x %d, y %d, width %d, height %d, xDest %d, yDest %d\n", region, x, y, width, height, xDest, yDest );
    if ((status = UNIX_CALL( glDrawBufferRegion, &args ))) WARN( "glDrawBufferRegion returned %#lx\n", status );
}

static void WINAPI glDrawBuffers( GLsizei n, const GLenum *bufs )
{
    struct glDrawBuffers_params args = { .teb = NtCurrentTeb(), .n = n, .bufs = bufs };
    NTSTATUS status;
    TRACE( "n %d, bufs %p\n", n, bufs );
    if ((status = UNIX_CALL( glDrawBuffers, &args ))) WARN( "glDrawBuffers returned %#lx\n", status );
}

static void WINAPI glDrawBuffersARB( GLsizei n, const GLenum *bufs )
{
    struct glDrawBuffersARB_params args = { .teb = NtCurrentTeb(), .n = n, .bufs = bufs };
    NTSTATUS status;
    TRACE( "n %d, bufs %p\n", n, bufs );
    if ((status = UNIX_CALL( glDrawBuffersARB, &args ))) WARN( "glDrawBuffersARB returned %#lx\n", status );
}

static void WINAPI glDrawBuffersATI( GLsizei n, const GLenum *bufs )
{
    struct glDrawBuffersATI_params args = { .teb = NtCurrentTeb(), .n = n, .bufs = bufs };
    NTSTATUS status;
    TRACE( "n %d, bufs %p\n", n, bufs );
    if ((status = UNIX_CALL( glDrawBuffersATI, &args ))) WARN( "glDrawBuffersATI returned %#lx\n", status );
}

static void WINAPI glDrawCommandsAddressNV( GLenum primitiveMode, const GLuint64 *indirects, const GLsizei *sizes, GLuint count )
{
    struct glDrawCommandsAddressNV_params args = { .teb = NtCurrentTeb(), .primitiveMode = primitiveMode, .indirects = indirects, .sizes = sizes, .count = count };
    NTSTATUS status;
    TRACE( "primitiveMode %d, indirects %p, sizes %p, count %d\n", primitiveMode, indirects, sizes, count );
    if ((status = UNIX_CALL( glDrawCommandsAddressNV, &args ))) WARN( "glDrawCommandsAddressNV returned %#lx\n", status );
}

static void WINAPI glDrawCommandsNV( GLenum primitiveMode, GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, GLuint count )
{
    struct glDrawCommandsNV_params args = { .teb = NtCurrentTeb(), .primitiveMode = primitiveMode, .buffer = buffer, .indirects = indirects, .sizes = sizes, .count = count };
    NTSTATUS status;
    TRACE( "primitiveMode %d, buffer %d, indirects %p, sizes %p, count %d\n", primitiveMode, buffer, indirects, sizes, count );
    if ((status = UNIX_CALL( glDrawCommandsNV, &args ))) WARN( "glDrawCommandsNV returned %#lx\n", status );
}

static void WINAPI glDrawCommandsStatesAddressNV( const GLuint64 *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count )
{
    struct glDrawCommandsStatesAddressNV_params args = { .teb = NtCurrentTeb(), .indirects = indirects, .sizes = sizes, .states = states, .fbos = fbos, .count = count };
    NTSTATUS status;
    TRACE( "indirects %p, sizes %p, states %p, fbos %p, count %d\n", indirects, sizes, states, fbos, count );
    if ((status = UNIX_CALL( glDrawCommandsStatesAddressNV, &args ))) WARN( "glDrawCommandsStatesAddressNV returned %#lx\n", status );
}

static void WINAPI glDrawCommandsStatesNV( GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count )
{
    struct glDrawCommandsStatesNV_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .indirects = indirects, .sizes = sizes, .states = states, .fbos = fbos, .count = count };
    NTSTATUS status;
    TRACE( "buffer %d, indirects %p, sizes %p, states %p, fbos %p, count %d\n", buffer, indirects, sizes, states, fbos, count );
    if ((status = UNIX_CALL( glDrawCommandsStatesNV, &args ))) WARN( "glDrawCommandsStatesNV returned %#lx\n", status );
}

static void WINAPI glDrawElementArrayAPPLE( GLenum mode, GLint first, GLsizei count )
{
    struct glDrawElementArrayAPPLE_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count };
    NTSTATUS status;
    TRACE( "mode %d, first %d, count %d\n", mode, first, count );
    if ((status = UNIX_CALL( glDrawElementArrayAPPLE, &args ))) WARN( "glDrawElementArrayAPPLE returned %#lx\n", status );
}

static void WINAPI glDrawElementArrayATI( GLenum mode, GLsizei count )
{
    struct glDrawElementArrayATI_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count };
    NTSTATUS status;
    TRACE( "mode %d, count %d\n", mode, count );
    if ((status = UNIX_CALL( glDrawElementArrayATI, &args ))) WARN( "glDrawElementArrayATI returned %#lx\n", status );
}

static void WINAPI glDrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex )
{
    struct glDrawElementsBaseVertex_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .basevertex = basevertex };
    NTSTATUS status;
    TRACE( "mode %d, count %d, type %d, indices %p, basevertex %d\n", mode, count, type, indices, basevertex );
    if ((status = UNIX_CALL( glDrawElementsBaseVertex, &args ))) WARN( "glDrawElementsBaseVertex returned %#lx\n", status );
}

static void WINAPI glDrawElementsIndirect( GLenum mode, GLenum type, const void *indirect )
{
    struct glDrawElementsIndirect_params args = { .teb = NtCurrentTeb(), .mode = mode, .type = type, .indirect = indirect };
    NTSTATUS status;
    TRACE( "mode %d, type %d, indirect %p\n", mode, type, indirect );
    if ((status = UNIX_CALL( glDrawElementsIndirect, &args ))) WARN( "glDrawElementsIndirect returned %#lx\n", status );
}

static void WINAPI glDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount )
{
    struct glDrawElementsInstanced_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .instancecount = instancecount };
    NTSTATUS status;
    TRACE( "mode %d, count %d, type %d, indices %p, instancecount %d\n", mode, count, type, indices, instancecount );
    if ((status = UNIX_CALL( glDrawElementsInstanced, &args ))) WARN( "glDrawElementsInstanced returned %#lx\n", status );
}

static void WINAPI glDrawElementsInstancedARB( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount )
{
    struct glDrawElementsInstancedARB_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .primcount = primcount };
    NTSTATUS status;
    TRACE( "mode %d, count %d, type %d, indices %p, primcount %d\n", mode, count, type, indices, primcount );
    if ((status = UNIX_CALL( glDrawElementsInstancedARB, &args ))) WARN( "glDrawElementsInstancedARB returned %#lx\n", status );
}

static void WINAPI glDrawElementsInstancedBaseInstance( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance )
{
    struct glDrawElementsInstancedBaseInstance_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .instancecount = instancecount, .baseinstance = baseinstance };
    NTSTATUS status;
    TRACE( "mode %d, count %d, type %d, indices %p, instancecount %d, baseinstance %d\n", mode, count, type, indices, instancecount, baseinstance );
    if ((status = UNIX_CALL( glDrawElementsInstancedBaseInstance, &args ))) WARN( "glDrawElementsInstancedBaseInstance returned %#lx\n", status );
}

static void WINAPI glDrawElementsInstancedBaseVertex( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex )
{
    struct glDrawElementsInstancedBaseVertex_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .instancecount = instancecount, .basevertex = basevertex };
    NTSTATUS status;
    TRACE( "mode %d, count %d, type %d, indices %p, instancecount %d, basevertex %d\n", mode, count, type, indices, instancecount, basevertex );
    if ((status = UNIX_CALL( glDrawElementsInstancedBaseVertex, &args ))) WARN( "glDrawElementsInstancedBaseVertex returned %#lx\n", status );
}

static void WINAPI glDrawElementsInstancedBaseVertexBaseInstance( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance )
{
    struct glDrawElementsInstancedBaseVertexBaseInstance_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .instancecount = instancecount, .basevertex = basevertex, .baseinstance = baseinstance };
    NTSTATUS status;
    TRACE( "mode %d, count %d, type %d, indices %p, instancecount %d, basevertex %d, baseinstance %d\n", mode, count, type, indices, instancecount, basevertex, baseinstance );
    if ((status = UNIX_CALL( glDrawElementsInstancedBaseVertexBaseInstance, &args ))) WARN( "glDrawElementsInstancedBaseVertexBaseInstance returned %#lx\n", status );
}

static void WINAPI glDrawElementsInstancedEXT( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount )
{
    struct glDrawElementsInstancedEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .primcount = primcount };
    NTSTATUS status;
    TRACE( "mode %d, count %d, type %d, indices %p, primcount %d\n", mode, count, type, indices, primcount );
    if ((status = UNIX_CALL( glDrawElementsInstancedEXT, &args ))) WARN( "glDrawElementsInstancedEXT returned %#lx\n", status );
}

static void WINAPI glDrawMeshArraysSUN( GLenum mode, GLint first, GLsizei count, GLsizei width )
{
    struct glDrawMeshArraysSUN_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count, .width = width };
    NTSTATUS status;
    TRACE( "mode %d, first %d, count %d, width %d\n", mode, first, count, width );
    if ((status = UNIX_CALL( glDrawMeshArraysSUN, &args ))) WARN( "glDrawMeshArraysSUN returned %#lx\n", status );
}

static void WINAPI glDrawMeshTasksIndirectNV( GLintptr indirect )
{
    struct glDrawMeshTasksIndirectNV_params args = { .teb = NtCurrentTeb(), .indirect = indirect };
    NTSTATUS status;
    TRACE( "indirect %Id\n", indirect );
    if ((status = UNIX_CALL( glDrawMeshTasksIndirectNV, &args ))) WARN( "glDrawMeshTasksIndirectNV returned %#lx\n", status );
}

static void WINAPI glDrawMeshTasksNV( GLuint first, GLuint count )
{
    struct glDrawMeshTasksNV_params args = { .teb = NtCurrentTeb(), .first = first, .count = count };
    NTSTATUS status;
    TRACE( "first %d, count %d\n", first, count );
    if ((status = UNIX_CALL( glDrawMeshTasksNV, &args ))) WARN( "glDrawMeshTasksNV returned %#lx\n", status );
}

static void WINAPI glDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count )
{
    struct glDrawRangeElementArrayAPPLE_params args = { .teb = NtCurrentTeb(), .mode = mode, .start = start, .end = end, .first = first, .count = count };
    NTSTATUS status;
    TRACE( "mode %d, start %d, end %d, first %d, count %d\n", mode, start, end, first, count );
    if ((status = UNIX_CALL( glDrawRangeElementArrayAPPLE, &args ))) WARN( "glDrawRangeElementArrayAPPLE returned %#lx\n", status );
}

static void WINAPI glDrawRangeElementArrayATI( GLenum mode, GLuint start, GLuint end, GLsizei count )
{
    struct glDrawRangeElementArrayATI_params args = { .teb = NtCurrentTeb(), .mode = mode, .start = start, .end = end, .count = count };
    NTSTATUS status;
    TRACE( "mode %d, start %d, end %d, count %d\n", mode, start, end, count );
    if ((status = UNIX_CALL( glDrawRangeElementArrayATI, &args ))) WARN( "glDrawRangeElementArrayATI returned %#lx\n", status );
}

static void WINAPI glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices )
{
    struct glDrawRangeElements_params args = { .teb = NtCurrentTeb(), .mode = mode, .start = start, .end = end, .count = count, .type = type, .indices = indices };
    NTSTATUS status;
    TRACE( "mode %d, start %d, end %d, count %d, type %d, indices %p\n", mode, start, end, count, type, indices );
    if ((status = UNIX_CALL( glDrawRangeElements, &args ))) WARN( "glDrawRangeElements returned %#lx\n", status );
}

static void WINAPI glDrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex )
{
    struct glDrawRangeElementsBaseVertex_params args = { .teb = NtCurrentTeb(), .mode = mode, .start = start, .end = end, .count = count, .type = type, .indices = indices, .basevertex = basevertex };
    NTSTATUS status;
    TRACE( "mode %d, start %d, end %d, count %d, type %d, indices %p, basevertex %d\n", mode, start, end, count, type, indices, basevertex );
    if ((status = UNIX_CALL( glDrawRangeElementsBaseVertex, &args ))) WARN( "glDrawRangeElementsBaseVertex returned %#lx\n", status );
}

static void WINAPI glDrawRangeElementsEXT( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices )
{
    struct glDrawRangeElementsEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .start = start, .end = end, .count = count, .type = type, .indices = indices };
    NTSTATUS status;
    TRACE( "mode %d, start %d, end %d, count %d, type %d, indices %p\n", mode, start, end, count, type, indices );
    if ((status = UNIX_CALL( glDrawRangeElementsEXT, &args ))) WARN( "glDrawRangeElementsEXT returned %#lx\n", status );
}

static void WINAPI glDrawTextureNV( GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 )
{
    struct glDrawTextureNV_params args = { .teb = NtCurrentTeb(), .texture = texture, .sampler = sampler, .x0 = x0, .y0 = y0, .x1 = x1, .y1 = y1, .z = z, .s0 = s0, .t0 = t0, .s1 = s1, .t1 = t1 };
    NTSTATUS status;
    TRACE( "texture %d, sampler %d, x0 %f, y0 %f, x1 %f, y1 %f, z %f, s0 %f, t0 %f, s1 %f, t1 %f\n", texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1 );
    if ((status = UNIX_CALL( glDrawTextureNV, &args ))) WARN( "glDrawTextureNV returned %#lx\n", status );
}

static void WINAPI glDrawTransformFeedback( GLenum mode, GLuint id )
{
    struct glDrawTransformFeedback_params args = { .teb = NtCurrentTeb(), .mode = mode, .id = id };
    NTSTATUS status;
    TRACE( "mode %d, id %d\n", mode, id );
    if ((status = UNIX_CALL( glDrawTransformFeedback, &args ))) WARN( "glDrawTransformFeedback returned %#lx\n", status );
}

static void WINAPI glDrawTransformFeedbackInstanced( GLenum mode, GLuint id, GLsizei instancecount )
{
    struct glDrawTransformFeedbackInstanced_params args = { .teb = NtCurrentTeb(), .mode = mode, .id = id, .instancecount = instancecount };
    NTSTATUS status;
    TRACE( "mode %d, id %d, instancecount %d\n", mode, id, instancecount );
    if ((status = UNIX_CALL( glDrawTransformFeedbackInstanced, &args ))) WARN( "glDrawTransformFeedbackInstanced returned %#lx\n", status );
}

static void WINAPI glDrawTransformFeedbackNV( GLenum mode, GLuint id )
{
    struct glDrawTransformFeedbackNV_params args = { .teb = NtCurrentTeb(), .mode = mode, .id = id };
    NTSTATUS status;
    TRACE( "mode %d, id %d\n", mode, id );
    if ((status = UNIX_CALL( glDrawTransformFeedbackNV, &args ))) WARN( "glDrawTransformFeedbackNV returned %#lx\n", status );
}

static void WINAPI glDrawTransformFeedbackStream( GLenum mode, GLuint id, GLuint stream )
{
    struct glDrawTransformFeedbackStream_params args = { .teb = NtCurrentTeb(), .mode = mode, .id = id, .stream = stream };
    NTSTATUS status;
    TRACE( "mode %d, id %d, stream %d\n", mode, id, stream );
    if ((status = UNIX_CALL( glDrawTransformFeedbackStream, &args ))) WARN( "glDrawTransformFeedbackStream returned %#lx\n", status );
}

static void WINAPI glDrawTransformFeedbackStreamInstanced( GLenum mode, GLuint id, GLuint stream, GLsizei instancecount )
{
    struct glDrawTransformFeedbackStreamInstanced_params args = { .teb = NtCurrentTeb(), .mode = mode, .id = id, .stream = stream, .instancecount = instancecount };
    NTSTATUS status;
    TRACE( "mode %d, id %d, stream %d, instancecount %d\n", mode, id, stream, instancecount );
    if ((status = UNIX_CALL( glDrawTransformFeedbackStreamInstanced, &args ))) WARN( "glDrawTransformFeedbackStreamInstanced returned %#lx\n", status );
}

static void WINAPI glDrawVkImageNV( GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 )
{
    struct glDrawVkImageNV_params args = { .teb = NtCurrentTeb(), .vkImage = vkImage, .sampler = sampler, .x0 = x0, .y0 = y0, .x1 = x1, .y1 = y1, .z = z, .s0 = s0, .t0 = t0, .s1 = s1, .t1 = t1 };
    NTSTATUS status;
    TRACE( "vkImage %s, sampler %d, x0 %f, y0 %f, x1 %f, y1 %f, z %f, s0 %f, t0 %f, s1 %f, t1 %f\n", wine_dbgstr_longlong(vkImage), sampler, x0, y0, x1, y1, z, s0, t0, s1, t1 );
    if ((status = UNIX_CALL( glDrawVkImageNV, &args ))) WARN( "glDrawVkImageNV returned %#lx\n", status );
}

static void WINAPI glEGLImageTargetTexStorageEXT( GLenum target, GLeglImageOES image, const GLint* attrib_list )
{
    struct glEGLImageTargetTexStorageEXT_params args = { .teb = NtCurrentTeb(), .target = target, .image = image, .attrib_list = attrib_list };
    NTSTATUS status;
    TRACE( "target %d, image %p, attrib_list %p\n", target, image, attrib_list );
    if ((status = UNIX_CALL( glEGLImageTargetTexStorageEXT, &args ))) WARN( "glEGLImageTargetTexStorageEXT returned %#lx\n", status );
}

static void WINAPI glEGLImageTargetTextureStorageEXT( GLuint texture, GLeglImageOES image, const GLint* attrib_list )
{
    struct glEGLImageTargetTextureStorageEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .image = image, .attrib_list = attrib_list };
    NTSTATUS status;
    TRACE( "texture %d, image %p, attrib_list %p\n", texture, image, attrib_list );
    if ((status = UNIX_CALL( glEGLImageTargetTextureStorageEXT, &args ))) WARN( "glEGLImageTargetTextureStorageEXT returned %#lx\n", status );
}

static void WINAPI glEdgeFlagFormatNV( GLsizei stride )
{
    struct glEdgeFlagFormatNV_params args = { .teb = NtCurrentTeb(), .stride = stride };
    NTSTATUS status;
    TRACE( "stride %d\n", stride );
    if ((status = UNIX_CALL( glEdgeFlagFormatNV, &args ))) WARN( "glEdgeFlagFormatNV returned %#lx\n", status );
}

static void WINAPI glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean *pointer )
{
    struct glEdgeFlagPointerEXT_params args = { .teb = NtCurrentTeb(), .stride = stride, .count = count, .pointer = pointer };
    NTSTATUS status;
    TRACE( "stride %d, count %d, pointer %p\n", stride, count, pointer );
    if ((status = UNIX_CALL( glEdgeFlagPointerEXT, &args ))) WARN( "glEdgeFlagPointerEXT returned %#lx\n", status );
}

static void WINAPI glEdgeFlagPointerListIBM( GLint stride, const GLboolean **pointer, GLint ptrstride )
{
    struct glEdgeFlagPointerListIBM_params args = { .teb = NtCurrentTeb(), .stride = stride, .pointer = pointer, .ptrstride = ptrstride };
    NTSTATUS status;
    TRACE( "stride %d, pointer %p, ptrstride %d\n", stride, pointer, ptrstride );
    if ((status = UNIX_CALL( glEdgeFlagPointerListIBM, &args ))) WARN( "glEdgeFlagPointerListIBM returned %#lx\n", status );
}

static void WINAPI glElementPointerAPPLE( GLenum type, const void *pointer )
{
    struct glElementPointerAPPLE_params args = { .teb = NtCurrentTeb(), .type = type, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, pointer %p\n", type, pointer );
    if ((status = UNIX_CALL( glElementPointerAPPLE, &args ))) WARN( "glElementPointerAPPLE returned %#lx\n", status );
}

static void WINAPI glElementPointerATI( GLenum type, const void *pointer )
{
    struct glElementPointerATI_params args = { .teb = NtCurrentTeb(), .type = type, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, pointer %p\n", type, pointer );
    if ((status = UNIX_CALL( glElementPointerATI, &args ))) WARN( "glElementPointerATI returned %#lx\n", status );
}

static void WINAPI glEnableClientStateIndexedEXT( GLenum array, GLuint index )
{
    struct glEnableClientStateIndexedEXT_params args = { .teb = NtCurrentTeb(), .array = array, .index = index };
    NTSTATUS status;
    TRACE( "array %d, index %d\n", array, index );
    if ((status = UNIX_CALL( glEnableClientStateIndexedEXT, &args ))) WARN( "glEnableClientStateIndexedEXT returned %#lx\n", status );
}

static void WINAPI glEnableClientStateiEXT( GLenum array, GLuint index )
{
    struct glEnableClientStateiEXT_params args = { .teb = NtCurrentTeb(), .array = array, .index = index };
    NTSTATUS status;
    TRACE( "array %d, index %d\n", array, index );
    if ((status = UNIX_CALL( glEnableClientStateiEXT, &args ))) WARN( "glEnableClientStateiEXT returned %#lx\n", status );
}

static void WINAPI glEnableIndexedEXT( GLenum target, GLuint index )
{
    struct glEnableIndexedEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index };
    NTSTATUS status;
    TRACE( "target %d, index %d\n", target, index );
    if ((status = UNIX_CALL( glEnableIndexedEXT, &args ))) WARN( "glEnableIndexedEXT returned %#lx\n", status );
}

static void WINAPI glEnableVariantClientStateEXT( GLuint id )
{
    struct glEnableVariantClientStateEXT_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glEnableVariantClientStateEXT, &args ))) WARN( "glEnableVariantClientStateEXT returned %#lx\n", status );
}

static void WINAPI glEnableVertexArrayAttrib( GLuint vaobj, GLuint index )
{
    struct glEnableVertexArrayAttrib_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d\n", vaobj, index );
    if ((status = UNIX_CALL( glEnableVertexArrayAttrib, &args ))) WARN( "glEnableVertexArrayAttrib returned %#lx\n", status );
}

static void WINAPI glEnableVertexArrayAttribEXT( GLuint vaobj, GLuint index )
{
    struct glEnableVertexArrayAttribEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d\n", vaobj, index );
    if ((status = UNIX_CALL( glEnableVertexArrayAttribEXT, &args ))) WARN( "glEnableVertexArrayAttribEXT returned %#lx\n", status );
}

static void WINAPI glEnableVertexArrayEXT( GLuint vaobj, GLenum array )
{
    struct glEnableVertexArrayEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .array = array };
    NTSTATUS status;
    TRACE( "vaobj %d, array %d\n", vaobj, array );
    if ((status = UNIX_CALL( glEnableVertexArrayEXT, &args ))) WARN( "glEnableVertexArrayEXT returned %#lx\n", status );
}

static void WINAPI glEnableVertexAttribAPPLE( GLuint index, GLenum pname )
{
    struct glEnableVertexAttribAPPLE_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname };
    NTSTATUS status;
    TRACE( "index %d, pname %d\n", index, pname );
    if ((status = UNIX_CALL( glEnableVertexAttribAPPLE, &args ))) WARN( "glEnableVertexAttribAPPLE returned %#lx\n", status );
}

static void WINAPI glEnableVertexAttribArray( GLuint index )
{
    struct glEnableVertexAttribArray_params args = { .teb = NtCurrentTeb(), .index = index };
    NTSTATUS status;
    TRACE( "index %d\n", index );
    if ((status = UNIX_CALL( glEnableVertexAttribArray, &args ))) WARN( "glEnableVertexAttribArray returned %#lx\n", status );
}

static void WINAPI glEnableVertexAttribArrayARB( GLuint index )
{
    struct glEnableVertexAttribArrayARB_params args = { .teb = NtCurrentTeb(), .index = index };
    NTSTATUS status;
    TRACE( "index %d\n", index );
    if ((status = UNIX_CALL( glEnableVertexAttribArrayARB, &args ))) WARN( "glEnableVertexAttribArrayARB returned %#lx\n", status );
}

static void WINAPI glEnablei( GLenum target, GLuint index )
{
    struct glEnablei_params args = { .teb = NtCurrentTeb(), .target = target, .index = index };
    NTSTATUS status;
    TRACE( "target %d, index %d\n", target, index );
    if ((status = UNIX_CALL( glEnablei, &args ))) WARN( "glEnablei returned %#lx\n", status );
}

static void WINAPI glEndConditionalRender(void)
{
    struct glEndConditionalRender_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndConditionalRender, &args ))) WARN( "glEndConditionalRender returned %#lx\n", status );
}

static void WINAPI glEndConditionalRenderNV(void)
{
    struct glEndConditionalRenderNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndConditionalRenderNV, &args ))) WARN( "glEndConditionalRenderNV returned %#lx\n", status );
}

static void WINAPI glEndConditionalRenderNVX(void)
{
    struct glEndConditionalRenderNVX_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndConditionalRenderNVX, &args ))) WARN( "glEndConditionalRenderNVX returned %#lx\n", status );
}

static void WINAPI glEndFragmentShaderATI(void)
{
    struct glEndFragmentShaderATI_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndFragmentShaderATI, &args ))) WARN( "glEndFragmentShaderATI returned %#lx\n", status );
}

static void WINAPI glEndOcclusionQueryNV(void)
{
    struct glEndOcclusionQueryNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndOcclusionQueryNV, &args ))) WARN( "glEndOcclusionQueryNV returned %#lx\n", status );
}

static void WINAPI glEndPerfMonitorAMD( GLuint monitor )
{
    struct glEndPerfMonitorAMD_params args = { .teb = NtCurrentTeb(), .monitor = monitor };
    NTSTATUS status;
    TRACE( "monitor %d\n", monitor );
    if ((status = UNIX_CALL( glEndPerfMonitorAMD, &args ))) WARN( "glEndPerfMonitorAMD returned %#lx\n", status );
}

static void WINAPI glEndPerfQueryINTEL( GLuint queryHandle )
{
    struct glEndPerfQueryINTEL_params args = { .teb = NtCurrentTeb(), .queryHandle = queryHandle };
    NTSTATUS status;
    TRACE( "queryHandle %d\n", queryHandle );
    if ((status = UNIX_CALL( glEndPerfQueryINTEL, &args ))) WARN( "glEndPerfQueryINTEL returned %#lx\n", status );
}

static void WINAPI glEndQuery( GLenum target )
{
    struct glEndQuery_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glEndQuery, &args ))) WARN( "glEndQuery returned %#lx\n", status );
}

static void WINAPI glEndQueryARB( GLenum target )
{
    struct glEndQueryARB_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glEndQueryARB, &args ))) WARN( "glEndQueryARB returned %#lx\n", status );
}

static void WINAPI glEndQueryIndexed( GLenum target, GLuint index )
{
    struct glEndQueryIndexed_params args = { .teb = NtCurrentTeb(), .target = target, .index = index };
    NTSTATUS status;
    TRACE( "target %d, index %d\n", target, index );
    if ((status = UNIX_CALL( glEndQueryIndexed, &args ))) WARN( "glEndQueryIndexed returned %#lx\n", status );
}

static void WINAPI glEndTransformFeedback(void)
{
    struct glEndTransformFeedback_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndTransformFeedback, &args ))) WARN( "glEndTransformFeedback returned %#lx\n", status );
}

static void WINAPI glEndTransformFeedbackEXT(void)
{
    struct glEndTransformFeedbackEXT_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndTransformFeedbackEXT, &args ))) WARN( "glEndTransformFeedbackEXT returned %#lx\n", status );
}

static void WINAPI glEndTransformFeedbackNV(void)
{
    struct glEndTransformFeedbackNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndTransformFeedbackNV, &args ))) WARN( "glEndTransformFeedbackNV returned %#lx\n", status );
}

static void WINAPI glEndVertexShaderEXT(void)
{
    struct glEndVertexShaderEXT_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEndVertexShaderEXT, &args ))) WARN( "glEndVertexShaderEXT returned %#lx\n", status );
}

static void WINAPI glEndVideoCaptureNV( GLuint video_capture_slot )
{
    struct glEndVideoCaptureNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot };
    NTSTATUS status;
    TRACE( "video_capture_slot %d\n", video_capture_slot );
    if ((status = UNIX_CALL( glEndVideoCaptureNV, &args ))) WARN( "glEndVideoCaptureNV returned %#lx\n", status );
}

static void WINAPI glEvalCoord1xOES( GLfixed u )
{
    struct glEvalCoord1xOES_params args = { .teb = NtCurrentTeb(), .u = u };
    NTSTATUS status;
    TRACE( "u %d\n", u );
    if ((status = UNIX_CALL( glEvalCoord1xOES, &args ))) WARN( "glEvalCoord1xOES returned %#lx\n", status );
}

static void WINAPI glEvalCoord1xvOES( const GLfixed *coords )
{
    struct glEvalCoord1xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glEvalCoord1xvOES, &args ))) WARN( "glEvalCoord1xvOES returned %#lx\n", status );
}

static void WINAPI glEvalCoord2xOES( GLfixed u, GLfixed v )
{
    struct glEvalCoord2xOES_params args = { .teb = NtCurrentTeb(), .u = u, .v = v };
    NTSTATUS status;
    TRACE( "u %d, v %d\n", u, v );
    if ((status = UNIX_CALL( glEvalCoord2xOES, &args ))) WARN( "glEvalCoord2xOES returned %#lx\n", status );
}

static void WINAPI glEvalCoord2xvOES( const GLfixed *coords )
{
    struct glEvalCoord2xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glEvalCoord2xvOES, &args ))) WARN( "glEvalCoord2xvOES returned %#lx\n", status );
}

static void WINAPI glEvalMapsNV( GLenum target, GLenum mode )
{
    struct glEvalMapsNV_params args = { .teb = NtCurrentTeb(), .target = target, .mode = mode };
    NTSTATUS status;
    TRACE( "target %d, mode %d\n", target, mode );
    if ((status = UNIX_CALL( glEvalMapsNV, &args ))) WARN( "glEvalMapsNV returned %#lx\n", status );
}

static void WINAPI glEvaluateDepthValuesARB(void)
{
    struct glEvaluateDepthValuesARB_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glEvaluateDepthValuesARB, &args ))) WARN( "glEvaluateDepthValuesARB returned %#lx\n", status );
}

static void WINAPI glExecuteProgramNV( GLenum target, GLuint id, const GLfloat *params )
{
    struct glExecuteProgramNV_params args = { .teb = NtCurrentTeb(), .target = target, .id = id, .params = params };
    NTSTATUS status;
    TRACE( "target %d, id %d, params %p\n", target, id, params );
    if ((status = UNIX_CALL( glExecuteProgramNV, &args ))) WARN( "glExecuteProgramNV returned %#lx\n", status );
}

static void WINAPI glExtractComponentEXT( GLuint res, GLuint src, GLuint num )
{
    struct glExtractComponentEXT_params args = { .teb = NtCurrentTeb(), .res = res, .src = src, .num = num };
    NTSTATUS status;
    TRACE( "res %d, src %d, num %d\n", res, src, num );
    if ((status = UNIX_CALL( glExtractComponentEXT, &args ))) WARN( "glExtractComponentEXT returned %#lx\n", status );
}

static void WINAPI glFeedbackBufferxOES( GLsizei n, GLenum type, const GLfixed *buffer )
{
    struct glFeedbackBufferxOES_params args = { .teb = NtCurrentTeb(), .n = n, .type = type, .buffer = buffer };
    NTSTATUS status;
    TRACE( "n %d, type %d, buffer %p\n", n, type, buffer );
    if ((status = UNIX_CALL( glFeedbackBufferxOES, &args ))) WARN( "glFeedbackBufferxOES returned %#lx\n", status );
}

static GLsync WINAPI glFenceSync( GLenum condition, GLbitfield flags )
{
    struct glFenceSync_params args = { .teb = NtCurrentTeb(), .condition = condition, .flags = flags };
    NTSTATUS status;
    TRACE( "condition %d, flags %d\n", condition, flags );
    if ((status = UNIX_CALL( glFenceSync, &args ))) WARN( "glFenceSync returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glFinalCombinerInputNV( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage )
{
    struct glFinalCombinerInputNV_params args = { .teb = NtCurrentTeb(), .variable = variable, .input = input, .mapping = mapping, .componentUsage = componentUsage };
    NTSTATUS status;
    TRACE( "variable %d, input %d, mapping %d, componentUsage %d\n", variable, input, mapping, componentUsage );
    if ((status = UNIX_CALL( glFinalCombinerInputNV, &args ))) WARN( "glFinalCombinerInputNV returned %#lx\n", status );
}

static GLint WINAPI glFinishAsyncSGIX( GLuint *markerp )
{
    struct glFinishAsyncSGIX_params args = { .teb = NtCurrentTeb(), .markerp = markerp };
    NTSTATUS status;
    TRACE( "markerp %p\n", markerp );
    if ((status = UNIX_CALL( glFinishAsyncSGIX, &args ))) WARN( "glFinishAsyncSGIX returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glFinishFenceAPPLE( GLuint fence )
{
    struct glFinishFenceAPPLE_params args = { .teb = NtCurrentTeb(), .fence = fence };
    NTSTATUS status;
    TRACE( "fence %d\n", fence );
    if ((status = UNIX_CALL( glFinishFenceAPPLE, &args ))) WARN( "glFinishFenceAPPLE returned %#lx\n", status );
}

static void WINAPI glFinishFenceNV( GLuint fence )
{
    struct glFinishFenceNV_params args = { .teb = NtCurrentTeb(), .fence = fence };
    NTSTATUS status;
    TRACE( "fence %d\n", fence );
    if ((status = UNIX_CALL( glFinishFenceNV, &args ))) WARN( "glFinishFenceNV returned %#lx\n", status );
}

static void WINAPI glFinishObjectAPPLE( GLenum object, GLint name )
{
    struct glFinishObjectAPPLE_params args = { .teb = NtCurrentTeb(), .object = object, .name = name };
    NTSTATUS status;
    TRACE( "object %d, name %d\n", object, name );
    if ((status = UNIX_CALL( glFinishObjectAPPLE, &args ))) WARN( "glFinishObjectAPPLE returned %#lx\n", status );
}

static void WINAPI glFinishTextureSUNX(void)
{
    struct glFinishTextureSUNX_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glFinishTextureSUNX, &args ))) WARN( "glFinishTextureSUNX returned %#lx\n", status );
}

static void WINAPI glFlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length )
{
    struct glFlushMappedBufferRange_params args = { .teb = NtCurrentTeb(), .target = target, .offset = offset, .length = length };
    NTSTATUS status;
    TRACE( "target %d, offset %Id, length %Id\n", target, offset, length );
    if ((status = UNIX_CALL( glFlushMappedBufferRange, &args ))) WARN( "glFlushMappedBufferRange returned %#lx\n", status );
}

static void WINAPI glFlushMappedBufferRangeAPPLE( GLenum target, GLintptr offset, GLsizeiptr size )
{
    struct glFlushMappedBufferRangeAPPLE_params args = { .teb = NtCurrentTeb(), .target = target, .offset = offset, .size = size };
    NTSTATUS status;
    TRACE( "target %d, offset %Id, size %Id\n", target, offset, size );
    if ((status = UNIX_CALL( glFlushMappedBufferRangeAPPLE, &args ))) WARN( "glFlushMappedBufferRangeAPPLE returned %#lx\n", status );
}

static void WINAPI glFlushMappedNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length )
{
    struct glFlushMappedNamedBufferRange_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .length = length };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, length %Id\n", buffer, offset, length );
    if ((status = UNIX_CALL( glFlushMappedNamedBufferRange, &args ))) WARN( "glFlushMappedNamedBufferRange returned %#lx\n", status );
}

static void WINAPI glFlushMappedNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length )
{
    struct glFlushMappedNamedBufferRangeEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .length = length };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, length %Id\n", buffer, offset, length );
    if ((status = UNIX_CALL( glFlushMappedNamedBufferRangeEXT, &args ))) WARN( "glFlushMappedNamedBufferRangeEXT returned %#lx\n", status );
}

static void WINAPI glFlushPixelDataRangeNV( GLenum target )
{
    struct glFlushPixelDataRangeNV_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glFlushPixelDataRangeNV, &args ))) WARN( "glFlushPixelDataRangeNV returned %#lx\n", status );
}

static void WINAPI glFlushRasterSGIX(void)
{
    struct glFlushRasterSGIX_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glFlushRasterSGIX, &args ))) WARN( "glFlushRasterSGIX returned %#lx\n", status );
}

static void WINAPI glFlushStaticDataIBM( GLenum target )
{
    struct glFlushStaticDataIBM_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glFlushStaticDataIBM, &args ))) WARN( "glFlushStaticDataIBM returned %#lx\n", status );
}

static void WINAPI glFlushVertexArrayRangeAPPLE( GLsizei length, void *pointer )
{
    struct glFlushVertexArrayRangeAPPLE_params args = { .teb = NtCurrentTeb(), .length = length, .pointer = pointer };
    NTSTATUS status;
    TRACE( "length %d, pointer %p\n", length, pointer );
    if ((status = UNIX_CALL( glFlushVertexArrayRangeAPPLE, &args ))) WARN( "glFlushVertexArrayRangeAPPLE returned %#lx\n", status );
}

static void WINAPI glFlushVertexArrayRangeNV(void)
{
    struct glFlushVertexArrayRangeNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glFlushVertexArrayRangeNV, &args ))) WARN( "glFlushVertexArrayRangeNV returned %#lx\n", status );
}

static void WINAPI glFogCoordFormatNV( GLenum type, GLsizei stride )
{
    struct glFogCoordFormatNV_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "type %d, stride %d\n", type, stride );
    if ((status = UNIX_CALL( glFogCoordFormatNV, &args ))) WARN( "glFogCoordFormatNV returned %#lx\n", status );
}

static void WINAPI glFogCoordPointer( GLenum type, GLsizei stride, const void *pointer )
{
    struct glFogCoordPointer_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
    if ((status = UNIX_CALL( glFogCoordPointer, &args ))) WARN( "glFogCoordPointer returned %#lx\n", status );
}

static void WINAPI glFogCoordPointerEXT( GLenum type, GLsizei stride, const void *pointer )
{
    struct glFogCoordPointerEXT_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
    if ((status = UNIX_CALL( glFogCoordPointerEXT, &args ))) WARN( "glFogCoordPointerEXT returned %#lx\n", status );
}

static void WINAPI glFogCoordPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride )
{
    struct glFogCoordPointerListIBM_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer, .ptrstride = ptrstride };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p, ptrstride %d\n", type, stride, pointer, ptrstride );
    if ((status = UNIX_CALL( glFogCoordPointerListIBM, &args ))) WARN( "glFogCoordPointerListIBM returned %#lx\n", status );
}

static void WINAPI glFogCoordd( GLdouble coord )
{
    struct glFogCoordd_params args = { .teb = NtCurrentTeb(), .coord = coord };
    NTSTATUS status;
    TRACE( "coord %f\n", coord );
    if ((status = UNIX_CALL( glFogCoordd, &args ))) WARN( "glFogCoordd returned %#lx\n", status );
}

static void WINAPI glFogCoorddEXT( GLdouble coord )
{
    struct glFogCoorddEXT_params args = { .teb = NtCurrentTeb(), .coord = coord };
    NTSTATUS status;
    TRACE( "coord %f\n", coord );
    if ((status = UNIX_CALL( glFogCoorddEXT, &args ))) WARN( "glFogCoorddEXT returned %#lx\n", status );
}

static void WINAPI glFogCoorddv( const GLdouble *coord )
{
    struct glFogCoorddv_params args = { .teb = NtCurrentTeb(), .coord = coord };
    NTSTATUS status;
    TRACE( "coord %p\n", coord );
    if ((status = UNIX_CALL( glFogCoorddv, &args ))) WARN( "glFogCoorddv returned %#lx\n", status );
}

static void WINAPI glFogCoorddvEXT( const GLdouble *coord )
{
    struct glFogCoorddvEXT_params args = { .teb = NtCurrentTeb(), .coord = coord };
    NTSTATUS status;
    TRACE( "coord %p\n", coord );
    if ((status = UNIX_CALL( glFogCoorddvEXT, &args ))) WARN( "glFogCoorddvEXT returned %#lx\n", status );
}

static void WINAPI glFogCoordf( GLfloat coord )
{
    struct glFogCoordf_params args = { .teb = NtCurrentTeb(), .coord = coord };
    NTSTATUS status;
    TRACE( "coord %f\n", coord );
    if ((status = UNIX_CALL( glFogCoordf, &args ))) WARN( "glFogCoordf returned %#lx\n", status );
}

static void WINAPI glFogCoordfEXT( GLfloat coord )
{
    struct glFogCoordfEXT_params args = { .teb = NtCurrentTeb(), .coord = coord };
    NTSTATUS status;
    TRACE( "coord %f\n", coord );
    if ((status = UNIX_CALL( glFogCoordfEXT, &args ))) WARN( "glFogCoordfEXT returned %#lx\n", status );
}

static void WINAPI glFogCoordfv( const GLfloat *coord )
{
    struct glFogCoordfv_params args = { .teb = NtCurrentTeb(), .coord = coord };
    NTSTATUS status;
    TRACE( "coord %p\n", coord );
    if ((status = UNIX_CALL( glFogCoordfv, &args ))) WARN( "glFogCoordfv returned %#lx\n", status );
}

static void WINAPI glFogCoordfvEXT( const GLfloat *coord )
{
    struct glFogCoordfvEXT_params args = { .teb = NtCurrentTeb(), .coord = coord };
    NTSTATUS status;
    TRACE( "coord %p\n", coord );
    if ((status = UNIX_CALL( glFogCoordfvEXT, &args ))) WARN( "glFogCoordfvEXT returned %#lx\n", status );
}

static void WINAPI glFogCoordhNV( GLhalfNV fog )
{
    struct glFogCoordhNV_params args = { .teb = NtCurrentTeb(), .fog = fog };
    NTSTATUS status;
    TRACE( "fog %d\n", fog );
    if ((status = UNIX_CALL( glFogCoordhNV, &args ))) WARN( "glFogCoordhNV returned %#lx\n", status );
}

static void WINAPI glFogCoordhvNV( const GLhalfNV *fog )
{
    struct glFogCoordhvNV_params args = { .teb = NtCurrentTeb(), .fog = fog };
    NTSTATUS status;
    TRACE( "fog %p\n", fog );
    if ((status = UNIX_CALL( glFogCoordhvNV, &args ))) WARN( "glFogCoordhvNV returned %#lx\n", status );
}

static void WINAPI glFogFuncSGIS( GLsizei n, const GLfloat *points )
{
    struct glFogFuncSGIS_params args = { .teb = NtCurrentTeb(), .n = n, .points = points };
    NTSTATUS status;
    TRACE( "n %d, points %p\n", n, points );
    if ((status = UNIX_CALL( glFogFuncSGIS, &args ))) WARN( "glFogFuncSGIS returned %#lx\n", status );
}

static void WINAPI glFogxOES( GLenum pname, GLfixed param )
{
    struct glFogxOES_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glFogxOES, &args ))) WARN( "glFogxOES returned %#lx\n", status );
}

static void WINAPI glFogxvOES( GLenum pname, const GLfixed *param )
{
    struct glFogxvOES_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %p\n", pname, param );
    if ((status = UNIX_CALL( glFogxvOES, &args ))) WARN( "glFogxvOES returned %#lx\n", status );
}

static void WINAPI glFragmentColorMaterialSGIX( GLenum face, GLenum mode )
{
    struct glFragmentColorMaterialSGIX_params args = { .teb = NtCurrentTeb(), .face = face, .mode = mode };
    NTSTATUS status;
    TRACE( "face %d, mode %d\n", face, mode );
    if ((status = UNIX_CALL( glFragmentColorMaterialSGIX, &args ))) WARN( "glFragmentColorMaterialSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentCoverageColorNV( GLuint color )
{
    struct glFragmentCoverageColorNV_params args = { .teb = NtCurrentTeb(), .color = color };
    NTSTATUS status;
    TRACE( "color %d\n", color );
    if ((status = UNIX_CALL( glFragmentCoverageColorNV, &args ))) WARN( "glFragmentCoverageColorNV returned %#lx\n", status );
}

static void WINAPI glFragmentLightModelfSGIX( GLenum pname, GLfloat param )
{
    struct glFragmentLightModelfSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glFragmentLightModelfSGIX, &args ))) WARN( "glFragmentLightModelfSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentLightModelfvSGIX( GLenum pname, const GLfloat *params )
{
    struct glFragmentLightModelfvSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glFragmentLightModelfvSGIX, &args ))) WARN( "glFragmentLightModelfvSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentLightModeliSGIX( GLenum pname, GLint param )
{
    struct glFragmentLightModeliSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glFragmentLightModeliSGIX, &args ))) WARN( "glFragmentLightModeliSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentLightModelivSGIX( GLenum pname, const GLint *params )
{
    struct glFragmentLightModelivSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glFragmentLightModelivSGIX, &args ))) WARN( "glFragmentLightModelivSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentLightfSGIX( GLenum light, GLenum pname, GLfloat param )
{
    struct glFragmentLightfSGIX_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "light %d, pname %d, param %f\n", light, pname, param );
    if ((status = UNIX_CALL( glFragmentLightfSGIX, &args ))) WARN( "glFragmentLightfSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentLightfvSGIX( GLenum light, GLenum pname, const GLfloat *params )
{
    struct glFragmentLightfvSGIX_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glFragmentLightfvSGIX, &args ))) WARN( "glFragmentLightfvSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentLightiSGIX( GLenum light, GLenum pname, GLint param )
{
    struct glFragmentLightiSGIX_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "light %d, pname %d, param %d\n", light, pname, param );
    if ((status = UNIX_CALL( glFragmentLightiSGIX, &args ))) WARN( "glFragmentLightiSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentLightivSGIX( GLenum light, GLenum pname, const GLint *params )
{
    struct glFragmentLightivSGIX_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glFragmentLightivSGIX, &args ))) WARN( "glFragmentLightivSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentMaterialfSGIX( GLenum face, GLenum pname, GLfloat param )
{
    struct glFragmentMaterialfSGIX_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "face %d, pname %d, param %f\n", face, pname, param );
    if ((status = UNIX_CALL( glFragmentMaterialfSGIX, &args ))) WARN( "glFragmentMaterialfSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentMaterialfvSGIX( GLenum face, GLenum pname, const GLfloat *params )
{
    struct glFragmentMaterialfvSGIX_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
    if ((status = UNIX_CALL( glFragmentMaterialfvSGIX, &args ))) WARN( "glFragmentMaterialfvSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentMaterialiSGIX( GLenum face, GLenum pname, GLint param )
{
    struct glFragmentMaterialiSGIX_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "face %d, pname %d, param %d\n", face, pname, param );
    if ((status = UNIX_CALL( glFragmentMaterialiSGIX, &args ))) WARN( "glFragmentMaterialiSGIX returned %#lx\n", status );
}

static void WINAPI glFragmentMaterialivSGIX( GLenum face, GLenum pname, const GLint *params )
{
    struct glFragmentMaterialivSGIX_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
    if ((status = UNIX_CALL( glFragmentMaterialivSGIX, &args ))) WARN( "glFragmentMaterialivSGIX returned %#lx\n", status );
}

static void WINAPI glFrameTerminatorGREMEDY(void)
{
    struct glFrameTerminatorGREMEDY_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glFrameTerminatorGREMEDY, &args ))) WARN( "glFrameTerminatorGREMEDY returned %#lx\n", status );
}

static void WINAPI glFrameZoomSGIX( GLint factor )
{
    struct glFrameZoomSGIX_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %d\n", factor );
    if ((status = UNIX_CALL( glFrameZoomSGIX, &args ))) WARN( "glFrameZoomSGIX returned %#lx\n", status );
}

static void WINAPI glFramebufferDrawBufferEXT( GLuint framebuffer, GLenum mode )
{
    struct glFramebufferDrawBufferEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .mode = mode };
    NTSTATUS status;
    TRACE( "framebuffer %d, mode %d\n", framebuffer, mode );
    if ((status = UNIX_CALL( glFramebufferDrawBufferEXT, &args ))) WARN( "glFramebufferDrawBufferEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferDrawBuffersEXT( GLuint framebuffer, GLsizei n, const GLenum *bufs )
{
    struct glFramebufferDrawBuffersEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .n = n, .bufs = bufs };
    NTSTATUS status;
    TRACE( "framebuffer %d, n %d, bufs %p\n", framebuffer, n, bufs );
    if ((status = UNIX_CALL( glFramebufferDrawBuffersEXT, &args ))) WARN( "glFramebufferDrawBuffersEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferFetchBarrierEXT(void)
{
    struct glFramebufferFetchBarrierEXT_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glFramebufferFetchBarrierEXT, &args ))) WARN( "glFramebufferFetchBarrierEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferParameteri( GLenum target, GLenum pname, GLint param )
{
    struct glFramebufferParameteri_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glFramebufferParameteri, &args ))) WARN( "glFramebufferParameteri returned %#lx\n", status );
}

static void WINAPI glFramebufferParameteriMESA( GLenum target, GLenum pname, GLint param )
{
    struct glFramebufferParameteriMESA_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glFramebufferParameteriMESA, &args ))) WARN( "glFramebufferParameteriMESA returned %#lx\n", status );
}

static void WINAPI glFramebufferReadBufferEXT( GLuint framebuffer, GLenum mode )
{
    struct glFramebufferReadBufferEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .mode = mode };
    NTSTATUS status;
    TRACE( "framebuffer %d, mode %d\n", framebuffer, mode );
    if ((status = UNIX_CALL( glFramebufferReadBufferEXT, &args ))) WARN( "glFramebufferReadBufferEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
{
    struct glFramebufferRenderbuffer_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .renderbuffertarget = renderbuffertarget, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, renderbuffertarget %d, renderbuffer %d\n", target, attachment, renderbuffertarget, renderbuffer );
    if ((status = UNIX_CALL( glFramebufferRenderbuffer, &args ))) WARN( "glFramebufferRenderbuffer returned %#lx\n", status );
}

static void WINAPI glFramebufferRenderbufferEXT( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
{
    struct glFramebufferRenderbufferEXT_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .renderbuffertarget = renderbuffertarget, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, renderbuffertarget %d, renderbuffer %d\n", target, attachment, renderbuffertarget, renderbuffer );
    if ((status = UNIX_CALL( glFramebufferRenderbufferEXT, &args ))) WARN( "glFramebufferRenderbufferEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferSampleLocationsfvARB( GLenum target, GLuint start, GLsizei count, const GLfloat *v )
{
    struct glFramebufferSampleLocationsfvARB_params args = { .teb = NtCurrentTeb(), .target = target, .start = start, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "target %d, start %d, count %d, v %p\n", target, start, count, v );
    if ((status = UNIX_CALL( glFramebufferSampleLocationsfvARB, &args ))) WARN( "glFramebufferSampleLocationsfvARB returned %#lx\n", status );
}

static void WINAPI glFramebufferSampleLocationsfvNV( GLenum target, GLuint start, GLsizei count, const GLfloat *v )
{
    struct glFramebufferSampleLocationsfvNV_params args = { .teb = NtCurrentTeb(), .target = target, .start = start, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "target %d, start %d, count %d, v %p\n", target, start, count, v );
    if ((status = UNIX_CALL( glFramebufferSampleLocationsfvNV, &args ))) WARN( "glFramebufferSampleLocationsfvNV returned %#lx\n", status );
}

static void WINAPI glFramebufferSamplePositionsfvAMD( GLenum target, GLuint numsamples, GLuint pixelindex, const GLfloat *values )
{
    struct glFramebufferSamplePositionsfvAMD_params args = { .teb = NtCurrentTeb(), .target = target, .numsamples = numsamples, .pixelindex = pixelindex, .values = values };
    NTSTATUS status;
    TRACE( "target %d, numsamples %d, pixelindex %d, values %p\n", target, numsamples, pixelindex, values );
    if ((status = UNIX_CALL( glFramebufferSamplePositionsfvAMD, &args ))) WARN( "glFramebufferSamplePositionsfvAMD returned %#lx\n", status );
}

static void WINAPI glFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level )
{
    struct glFramebufferTexture_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d\n", target, attachment, texture, level );
    if ((status = UNIX_CALL( glFramebufferTexture, &args ))) WARN( "glFramebufferTexture returned %#lx\n", status );
}

static void WINAPI glFramebufferTexture1D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
    struct glFramebufferTexture1D_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, textarget %d, texture %d, level %d\n", target, attachment, textarget, texture, level );
    if ((status = UNIX_CALL( glFramebufferTexture1D, &args ))) WARN( "glFramebufferTexture1D returned %#lx\n", status );
}

static void WINAPI glFramebufferTexture1DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
    struct glFramebufferTexture1DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, textarget %d, texture %d, level %d\n", target, attachment, textarget, texture, level );
    if ((status = UNIX_CALL( glFramebufferTexture1DEXT, &args ))) WARN( "glFramebufferTexture1DEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
    struct glFramebufferTexture2D_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, textarget %d, texture %d, level %d\n", target, attachment, textarget, texture, level );
    if ((status = UNIX_CALL( glFramebufferTexture2D, &args ))) WARN( "glFramebufferTexture2D returned %#lx\n", status );
}

static void WINAPI glFramebufferTexture2DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
    struct glFramebufferTexture2DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, textarget %d, texture %d, level %d\n", target, attachment, textarget, texture, level );
    if ((status = UNIX_CALL( glFramebufferTexture2DEXT, &args ))) WARN( "glFramebufferTexture2DEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferTexture3D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset )
{
    struct glFramebufferTexture3D_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level, .zoffset = zoffset };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, textarget %d, texture %d, level %d, zoffset %d\n", target, attachment, textarget, texture, level, zoffset );
    if ((status = UNIX_CALL( glFramebufferTexture3D, &args ))) WARN( "glFramebufferTexture3D returned %#lx\n", status );
}

static void WINAPI glFramebufferTexture3DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset )
{
    struct glFramebufferTexture3DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level, .zoffset = zoffset };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, textarget %d, texture %d, level %d, zoffset %d\n", target, attachment, textarget, texture, level, zoffset );
    if ((status = UNIX_CALL( glFramebufferTexture3DEXT, &args ))) WARN( "glFramebufferTexture3DEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferTextureARB( GLenum target, GLenum attachment, GLuint texture, GLint level )
{
    struct glFramebufferTextureARB_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d\n", target, attachment, texture, level );
    if ((status = UNIX_CALL( glFramebufferTextureARB, &args ))) WARN( "glFramebufferTextureARB returned %#lx\n", status );
}

static void WINAPI glFramebufferTextureEXT( GLenum target, GLenum attachment, GLuint texture, GLint level )
{
    struct glFramebufferTextureEXT_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d\n", target, attachment, texture, level );
    if ((status = UNIX_CALL( glFramebufferTextureEXT, &args ))) WARN( "glFramebufferTextureEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferTextureFaceARB( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face )
{
    struct glFramebufferTextureFaceARB_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level, .face = face };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d, face %d\n", target, attachment, texture, level, face );
    if ((status = UNIX_CALL( glFramebufferTextureFaceARB, &args ))) WARN( "glFramebufferTextureFaceARB returned %#lx\n", status );
}

static void WINAPI glFramebufferTextureFaceEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face )
{
    struct glFramebufferTextureFaceEXT_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level, .face = face };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d, face %d\n", target, attachment, texture, level, face );
    if ((status = UNIX_CALL( glFramebufferTextureFaceEXT, &args ))) WARN( "glFramebufferTextureFaceEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer )
{
    struct glFramebufferTextureLayer_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level, .layer = layer };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d, layer %d\n", target, attachment, texture, level, layer );
    if ((status = UNIX_CALL( glFramebufferTextureLayer, &args ))) WARN( "glFramebufferTextureLayer returned %#lx\n", status );
}

static void WINAPI glFramebufferTextureLayerARB( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer )
{
    struct glFramebufferTextureLayerARB_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level, .layer = layer };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d, layer %d\n", target, attachment, texture, level, layer );
    if ((status = UNIX_CALL( glFramebufferTextureLayerARB, &args ))) WARN( "glFramebufferTextureLayerARB returned %#lx\n", status );
}

static void WINAPI glFramebufferTextureLayerEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer )
{
    struct glFramebufferTextureLayerEXT_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level, .layer = layer };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d, layer %d\n", target, attachment, texture, level, layer );
    if ((status = UNIX_CALL( glFramebufferTextureLayerEXT, &args ))) WARN( "glFramebufferTextureLayerEXT returned %#lx\n", status );
}

static void WINAPI glFramebufferTextureMultiviewOVR( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews )
{
    struct glFramebufferTextureMultiviewOVR_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .texture = texture, .level = level, .baseViewIndex = baseViewIndex, .numViews = numViews };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, texture %d, level %d, baseViewIndex %d, numViews %d\n", target, attachment, texture, level, baseViewIndex, numViews );
    if ((status = UNIX_CALL( glFramebufferTextureMultiviewOVR, &args ))) WARN( "glFramebufferTextureMultiviewOVR returned %#lx\n", status );
}

static void WINAPI glFreeObjectBufferATI( GLuint buffer )
{
    struct glFreeObjectBufferATI_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glFreeObjectBufferATI, &args ))) WARN( "glFreeObjectBufferATI returned %#lx\n", status );
}

static void WINAPI glFrustumfOES( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f )
{
    struct glFrustumfOES_params args = { .teb = NtCurrentTeb(), .l = l, .r = r, .b = b, .t = t, .n = n, .f = f };
    NTSTATUS status;
    TRACE( "l %f, r %f, b %f, t %f, n %f, f %f\n", l, r, b, t, n, f );
    if ((status = UNIX_CALL( glFrustumfOES, &args ))) WARN( "glFrustumfOES returned %#lx\n", status );
}

static void WINAPI glFrustumxOES( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f )
{
    struct glFrustumxOES_params args = { .teb = NtCurrentTeb(), .l = l, .r = r, .b = b, .t = t, .n = n, .f = f };
    NTSTATUS status;
    TRACE( "l %d, r %d, b %d, t %d, n %d, f %d\n", l, r, b, t, n, f );
    if ((status = UNIX_CALL( glFrustumxOES, &args ))) WARN( "glFrustumxOES returned %#lx\n", status );
}

static GLuint WINAPI glGenAsyncMarkersSGIX( GLsizei range )
{
    struct glGenAsyncMarkersSGIX_params args = { .teb = NtCurrentTeb(), .range = range };
    NTSTATUS status;
    TRACE( "range %d\n", range );
    if ((status = UNIX_CALL( glGenAsyncMarkersSGIX, &args ))) WARN( "glGenAsyncMarkersSGIX returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGenBuffers( GLsizei n, GLuint *buffers )
{
    struct glGenBuffers_params args = { .teb = NtCurrentTeb(), .n = n, .buffers = buffers };
    NTSTATUS status;
    TRACE( "n %d, buffers %p\n", n, buffers );
    if ((status = UNIX_CALL( glGenBuffers, &args ))) WARN( "glGenBuffers returned %#lx\n", status );
}

static void WINAPI glGenBuffersARB( GLsizei n, GLuint *buffers )
{
    struct glGenBuffersARB_params args = { .teb = NtCurrentTeb(), .n = n, .buffers = buffers };
    NTSTATUS status;
    TRACE( "n %d, buffers %p\n", n, buffers );
    if ((status = UNIX_CALL( glGenBuffersARB, &args ))) WARN( "glGenBuffersARB returned %#lx\n", status );
}

static void WINAPI glGenFencesAPPLE( GLsizei n, GLuint *fences )
{
    struct glGenFencesAPPLE_params args = { .teb = NtCurrentTeb(), .n = n, .fences = fences };
    NTSTATUS status;
    TRACE( "n %d, fences %p\n", n, fences );
    if ((status = UNIX_CALL( glGenFencesAPPLE, &args ))) WARN( "glGenFencesAPPLE returned %#lx\n", status );
}

static void WINAPI glGenFencesNV( GLsizei n, GLuint *fences )
{
    struct glGenFencesNV_params args = { .teb = NtCurrentTeb(), .n = n, .fences = fences };
    NTSTATUS status;
    TRACE( "n %d, fences %p\n", n, fences );
    if ((status = UNIX_CALL( glGenFencesNV, &args ))) WARN( "glGenFencesNV returned %#lx\n", status );
}

static GLuint WINAPI glGenFragmentShadersATI( GLuint range )
{
    struct glGenFragmentShadersATI_params args = { .teb = NtCurrentTeb(), .range = range };
    NTSTATUS status;
    TRACE( "range %d\n", range );
    if ((status = UNIX_CALL( glGenFragmentShadersATI, &args ))) WARN( "glGenFragmentShadersATI returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGenFramebuffers( GLsizei n, GLuint *framebuffers )
{
    struct glGenFramebuffers_params args = { .teb = NtCurrentTeb(), .n = n, .framebuffers = framebuffers };
    NTSTATUS status;
    TRACE( "n %d, framebuffers %p\n", n, framebuffers );
    if ((status = UNIX_CALL( glGenFramebuffers, &args ))) WARN( "glGenFramebuffers returned %#lx\n", status );
}

static void WINAPI glGenFramebuffersEXT( GLsizei n, GLuint *framebuffers )
{
    struct glGenFramebuffersEXT_params args = { .teb = NtCurrentTeb(), .n = n, .framebuffers = framebuffers };
    NTSTATUS status;
    TRACE( "n %d, framebuffers %p\n", n, framebuffers );
    if ((status = UNIX_CALL( glGenFramebuffersEXT, &args ))) WARN( "glGenFramebuffersEXT returned %#lx\n", status );
}

static void WINAPI glGenNamesAMD( GLenum identifier, GLuint num, GLuint *names )
{
    struct glGenNamesAMD_params args = { .teb = NtCurrentTeb(), .identifier = identifier, .num = num, .names = names };
    NTSTATUS status;
    TRACE( "identifier %d, num %d, names %p\n", identifier, num, names );
    if ((status = UNIX_CALL( glGenNamesAMD, &args ))) WARN( "glGenNamesAMD returned %#lx\n", status );
}

static void WINAPI glGenOcclusionQueriesNV( GLsizei n, GLuint *ids )
{
    struct glGenOcclusionQueriesNV_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glGenOcclusionQueriesNV, &args ))) WARN( "glGenOcclusionQueriesNV returned %#lx\n", status );
}

static GLuint WINAPI glGenPathsNV( GLsizei range )
{
    struct glGenPathsNV_params args = { .teb = NtCurrentTeb(), .range = range };
    NTSTATUS status;
    TRACE( "range %d\n", range );
    if ((status = UNIX_CALL( glGenPathsNV, &args ))) WARN( "glGenPathsNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGenPerfMonitorsAMD( GLsizei n, GLuint *monitors )
{
    struct glGenPerfMonitorsAMD_params args = { .teb = NtCurrentTeb(), .n = n, .monitors = monitors };
    NTSTATUS status;
    TRACE( "n %d, monitors %p\n", n, monitors );
    if ((status = UNIX_CALL( glGenPerfMonitorsAMD, &args ))) WARN( "glGenPerfMonitorsAMD returned %#lx\n", status );
}

static void WINAPI glGenProgramPipelines( GLsizei n, GLuint *pipelines )
{
    struct glGenProgramPipelines_params args = { .teb = NtCurrentTeb(), .n = n, .pipelines = pipelines };
    NTSTATUS status;
    TRACE( "n %d, pipelines %p\n", n, pipelines );
    if ((status = UNIX_CALL( glGenProgramPipelines, &args ))) WARN( "glGenProgramPipelines returned %#lx\n", status );
}

static void WINAPI glGenProgramsARB( GLsizei n, GLuint *programs )
{
    struct glGenProgramsARB_params args = { .teb = NtCurrentTeb(), .n = n, .programs = programs };
    NTSTATUS status;
    TRACE( "n %d, programs %p\n", n, programs );
    if ((status = UNIX_CALL( glGenProgramsARB, &args ))) WARN( "glGenProgramsARB returned %#lx\n", status );
}

static void WINAPI glGenProgramsNV( GLsizei n, GLuint *programs )
{
    struct glGenProgramsNV_params args = { .teb = NtCurrentTeb(), .n = n, .programs = programs };
    NTSTATUS status;
    TRACE( "n %d, programs %p\n", n, programs );
    if ((status = UNIX_CALL( glGenProgramsNV, &args ))) WARN( "glGenProgramsNV returned %#lx\n", status );
}

static void WINAPI glGenQueries( GLsizei n, GLuint *ids )
{
    struct glGenQueries_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glGenQueries, &args ))) WARN( "glGenQueries returned %#lx\n", status );
}

static void WINAPI glGenQueriesARB( GLsizei n, GLuint *ids )
{
    struct glGenQueriesARB_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glGenQueriesARB, &args ))) WARN( "glGenQueriesARB returned %#lx\n", status );
}

static void WINAPI glGenQueryResourceTagNV( GLsizei n, GLint *tagIds )
{
    struct glGenQueryResourceTagNV_params args = { .teb = NtCurrentTeb(), .n = n, .tagIds = tagIds };
    NTSTATUS status;
    TRACE( "n %d, tagIds %p\n", n, tagIds );
    if ((status = UNIX_CALL( glGenQueryResourceTagNV, &args ))) WARN( "glGenQueryResourceTagNV returned %#lx\n", status );
}

static void WINAPI glGenRenderbuffers( GLsizei n, GLuint *renderbuffers )
{
    struct glGenRenderbuffers_params args = { .teb = NtCurrentTeb(), .n = n, .renderbuffers = renderbuffers };
    NTSTATUS status;
    TRACE( "n %d, renderbuffers %p\n", n, renderbuffers );
    if ((status = UNIX_CALL( glGenRenderbuffers, &args ))) WARN( "glGenRenderbuffers returned %#lx\n", status );
}

static void WINAPI glGenRenderbuffersEXT( GLsizei n, GLuint *renderbuffers )
{
    struct glGenRenderbuffersEXT_params args = { .teb = NtCurrentTeb(), .n = n, .renderbuffers = renderbuffers };
    NTSTATUS status;
    TRACE( "n %d, renderbuffers %p\n", n, renderbuffers );
    if ((status = UNIX_CALL( glGenRenderbuffersEXT, &args ))) WARN( "glGenRenderbuffersEXT returned %#lx\n", status );
}

static void WINAPI glGenSamplers( GLsizei count, GLuint *samplers )
{
    struct glGenSamplers_params args = { .teb = NtCurrentTeb(), .count = count, .samplers = samplers };
    NTSTATUS status;
    TRACE( "count %d, samplers %p\n", count, samplers );
    if ((status = UNIX_CALL( glGenSamplers, &args ))) WARN( "glGenSamplers returned %#lx\n", status );
}

static void WINAPI glGenSemaphoresEXT( GLsizei n, GLuint *semaphores )
{
    struct glGenSemaphoresEXT_params args = { .teb = NtCurrentTeb(), .n = n, .semaphores = semaphores };
    NTSTATUS status;
    TRACE( "n %d, semaphores %p\n", n, semaphores );
    if ((status = UNIX_CALL( glGenSemaphoresEXT, &args ))) WARN( "glGenSemaphoresEXT returned %#lx\n", status );
}

static GLuint WINAPI glGenSymbolsEXT( GLenum datatype, GLenum storagetype, GLenum range, GLuint components )
{
    struct glGenSymbolsEXT_params args = { .teb = NtCurrentTeb(), .datatype = datatype, .storagetype = storagetype, .range = range, .components = components };
    NTSTATUS status;
    TRACE( "datatype %d, storagetype %d, range %d, components %d\n", datatype, storagetype, range, components );
    if ((status = UNIX_CALL( glGenSymbolsEXT, &args ))) WARN( "glGenSymbolsEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGenTexturesEXT( GLsizei n, GLuint *textures )
{
    struct glGenTexturesEXT_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures };
    NTSTATUS status;
    TRACE( "n %d, textures %p\n", n, textures );
    if ((status = UNIX_CALL( glGenTexturesEXT, &args ))) WARN( "glGenTexturesEXT returned %#lx\n", status );
}

static void WINAPI glGenTransformFeedbacks( GLsizei n, GLuint *ids )
{
    struct glGenTransformFeedbacks_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glGenTransformFeedbacks, &args ))) WARN( "glGenTransformFeedbacks returned %#lx\n", status );
}

static void WINAPI glGenTransformFeedbacksNV( GLsizei n, GLuint *ids )
{
    struct glGenTransformFeedbacksNV_params args = { .teb = NtCurrentTeb(), .n = n, .ids = ids };
    NTSTATUS status;
    TRACE( "n %d, ids %p\n", n, ids );
    if ((status = UNIX_CALL( glGenTransformFeedbacksNV, &args ))) WARN( "glGenTransformFeedbacksNV returned %#lx\n", status );
}

static void WINAPI glGenVertexArrays( GLsizei n, GLuint *arrays )
{
    struct glGenVertexArrays_params args = { .teb = NtCurrentTeb(), .n = n, .arrays = arrays };
    NTSTATUS status;
    TRACE( "n %d, arrays %p\n", n, arrays );
    if ((status = UNIX_CALL( glGenVertexArrays, &args ))) WARN( "glGenVertexArrays returned %#lx\n", status );
}

static void WINAPI glGenVertexArraysAPPLE( GLsizei n, GLuint *arrays )
{
    struct glGenVertexArraysAPPLE_params args = { .teb = NtCurrentTeb(), .n = n, .arrays = arrays };
    NTSTATUS status;
    TRACE( "n %d, arrays %p\n", n, arrays );
    if ((status = UNIX_CALL( glGenVertexArraysAPPLE, &args ))) WARN( "glGenVertexArraysAPPLE returned %#lx\n", status );
}

static GLuint WINAPI glGenVertexShadersEXT( GLuint range )
{
    struct glGenVertexShadersEXT_params args = { .teb = NtCurrentTeb(), .range = range };
    NTSTATUS status;
    TRACE( "range %d\n", range );
    if ((status = UNIX_CALL( glGenVertexShadersEXT, &args ))) WARN( "glGenVertexShadersEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGenerateMipmap( GLenum target )
{
    struct glGenerateMipmap_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glGenerateMipmap, &args ))) WARN( "glGenerateMipmap returned %#lx\n", status );
}

static void WINAPI glGenerateMipmapEXT( GLenum target )
{
    struct glGenerateMipmapEXT_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glGenerateMipmapEXT, &args ))) WARN( "glGenerateMipmapEXT returned %#lx\n", status );
}

static void WINAPI glGenerateMultiTexMipmapEXT( GLenum texunit, GLenum target )
{
    struct glGenerateMultiTexMipmapEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target };
    NTSTATUS status;
    TRACE( "texunit %d, target %d\n", texunit, target );
    if ((status = UNIX_CALL( glGenerateMultiTexMipmapEXT, &args ))) WARN( "glGenerateMultiTexMipmapEXT returned %#lx\n", status );
}

static void WINAPI glGenerateTextureMipmap( GLuint texture )
{
    struct glGenerateTextureMipmap_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glGenerateTextureMipmap, &args ))) WARN( "glGenerateTextureMipmap returned %#lx\n", status );
}

static void WINAPI glGenerateTextureMipmapEXT( GLuint texture, GLenum target )
{
    struct glGenerateTextureMipmapEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target };
    NTSTATUS status;
    TRACE( "texture %d, target %d\n", texture, target );
    if ((status = UNIX_CALL( glGenerateTextureMipmapEXT, &args ))) WARN( "glGenerateTextureMipmapEXT returned %#lx\n", status );
}

static void WINAPI glGetActiveAtomicCounterBufferiv( GLuint program, GLuint bufferIndex, GLenum pname, GLint *params )
{
    struct glGetActiveAtomicCounterBufferiv_params args = { .teb = NtCurrentTeb(), .program = program, .bufferIndex = bufferIndex, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "program %d, bufferIndex %d, pname %d, params %p\n", program, bufferIndex, pname, params );
    if ((status = UNIX_CALL( glGetActiveAtomicCounterBufferiv, &args ))) WARN( "glGetActiveAtomicCounterBufferiv returned %#lx\n", status );
}

static void WINAPI glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name )
{
    struct glGetActiveAttrib_params args = { .teb = NtCurrentTeb(), .program = program, .index = index, .bufSize = bufSize, .length = length, .size = size, .type = type, .name = name };
    NTSTATUS status;
    TRACE( "program %d, index %d, bufSize %d, length %p, size %p, type %p, name %p\n", program, index, bufSize, length, size, type, name );
    if ((status = UNIX_CALL( glGetActiveAttrib, &args ))) WARN( "glGetActiveAttrib returned %#lx\n", status );
}

static void WINAPI glGetActiveAttribARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name )
{
    struct glGetActiveAttribARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj, .index = index, .maxLength = maxLength, .length = length, .size = size, .type = type, .name = name };
    NTSTATUS status;
    TRACE( "programObj %d, index %d, maxLength %d, length %p, size %p, type %p, name %p\n", programObj, index, maxLength, length, size, type, name );
    if ((status = UNIX_CALL( glGetActiveAttribARB, &args ))) WARN( "glGetActiveAttribARB returned %#lx\n", status );
}

static void WINAPI glGetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name )
{
    struct glGetActiveSubroutineName_params args = { .teb = NtCurrentTeb(), .program = program, .shadertype = shadertype, .index = index, .bufSize = bufSize, .length = length, .name = name };
    NTSTATUS status;
    TRACE( "program %d, shadertype %d, index %d, bufSize %d, length %p, name %p\n", program, shadertype, index, bufSize, length, name );
    if ((status = UNIX_CALL( glGetActiveSubroutineName, &args ))) WARN( "glGetActiveSubroutineName returned %#lx\n", status );
}

static void WINAPI glGetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name )
{
    struct glGetActiveSubroutineUniformName_params args = { .teb = NtCurrentTeb(), .program = program, .shadertype = shadertype, .index = index, .bufSize = bufSize, .length = length, .name = name };
    NTSTATUS status;
    TRACE( "program %d, shadertype %d, index %d, bufSize %d, length %p, name %p\n", program, shadertype, index, bufSize, length, name );
    if ((status = UNIX_CALL( glGetActiveSubroutineUniformName, &args ))) WARN( "glGetActiveSubroutineUniformName returned %#lx\n", status );
}

static void WINAPI glGetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values )
{
    struct glGetActiveSubroutineUniformiv_params args = { .teb = NtCurrentTeb(), .program = program, .shadertype = shadertype, .index = index, .pname = pname, .values = values };
    NTSTATUS status;
    TRACE( "program %d, shadertype %d, index %d, pname %d, values %p\n", program, shadertype, index, pname, values );
    if ((status = UNIX_CALL( glGetActiveSubroutineUniformiv, &args ))) WARN( "glGetActiveSubroutineUniformiv returned %#lx\n", status );
}

static void WINAPI glGetActiveUniform( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name )
{
    struct glGetActiveUniform_params args = { .teb = NtCurrentTeb(), .program = program, .index = index, .bufSize = bufSize, .length = length, .size = size, .type = type, .name = name };
    NTSTATUS status;
    TRACE( "program %d, index %d, bufSize %d, length %p, size %p, type %p, name %p\n", program, index, bufSize, length, size, type, name );
    if ((status = UNIX_CALL( glGetActiveUniform, &args ))) WARN( "glGetActiveUniform returned %#lx\n", status );
}

static void WINAPI glGetActiveUniformARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name )
{
    struct glGetActiveUniformARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj, .index = index, .maxLength = maxLength, .length = length, .size = size, .type = type, .name = name };
    NTSTATUS status;
    TRACE( "programObj %d, index %d, maxLength %d, length %p, size %p, type %p, name %p\n", programObj, index, maxLength, length, size, type, name );
    if ((status = UNIX_CALL( glGetActiveUniformARB, &args ))) WARN( "glGetActiveUniformARB returned %#lx\n", status );
}

static void WINAPI glGetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName )
{
    struct glGetActiveUniformBlockName_params args = { .teb = NtCurrentTeb(), .program = program, .uniformBlockIndex = uniformBlockIndex, .bufSize = bufSize, .length = length, .uniformBlockName = uniformBlockName };
    NTSTATUS status;
    TRACE( "program %d, uniformBlockIndex %d, bufSize %d, length %p, uniformBlockName %p\n", program, uniformBlockIndex, bufSize, length, uniformBlockName );
    if ((status = UNIX_CALL( glGetActiveUniformBlockName, &args ))) WARN( "glGetActiveUniformBlockName returned %#lx\n", status );
}

static void WINAPI glGetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params )
{
    struct glGetActiveUniformBlockiv_params args = { .teb = NtCurrentTeb(), .program = program, .uniformBlockIndex = uniformBlockIndex, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "program %d, uniformBlockIndex %d, pname %d, params %p\n", program, uniformBlockIndex, pname, params );
    if ((status = UNIX_CALL( glGetActiveUniformBlockiv, &args ))) WARN( "glGetActiveUniformBlockiv returned %#lx\n", status );
}

static void WINAPI glGetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName )
{
    struct glGetActiveUniformName_params args = { .teb = NtCurrentTeb(), .program = program, .uniformIndex = uniformIndex, .bufSize = bufSize, .length = length, .uniformName = uniformName };
    NTSTATUS status;
    TRACE( "program %d, uniformIndex %d, bufSize %d, length %p, uniformName %p\n", program, uniformIndex, bufSize, length, uniformName );
    if ((status = UNIX_CALL( glGetActiveUniformName, &args ))) WARN( "glGetActiveUniformName returned %#lx\n", status );
}

static void WINAPI glGetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params )
{
    struct glGetActiveUniformsiv_params args = { .teb = NtCurrentTeb(), .program = program, .uniformCount = uniformCount, .uniformIndices = uniformIndices, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "program %d, uniformCount %d, uniformIndices %p, pname %d, params %p\n", program, uniformCount, uniformIndices, pname, params );
    if ((status = UNIX_CALL( glGetActiveUniformsiv, &args ))) WARN( "glGetActiveUniformsiv returned %#lx\n", status );
}

static void WINAPI glGetActiveVaryingNV( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name )
{
    struct glGetActiveVaryingNV_params args = { .teb = NtCurrentTeb(), .program = program, .index = index, .bufSize = bufSize, .length = length, .size = size, .type = type, .name = name };
    NTSTATUS status;
    TRACE( "program %d, index %d, bufSize %d, length %p, size %p, type %p, name %p\n", program, index, bufSize, length, size, type, name );
    if ((status = UNIX_CALL( glGetActiveVaryingNV, &args ))) WARN( "glGetActiveVaryingNV returned %#lx\n", status );
}

static void WINAPI glGetArrayObjectfvATI( GLenum array, GLenum pname, GLfloat *params )
{
    struct glGetArrayObjectfvATI_params args = { .teb = NtCurrentTeb(), .array = array, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "array %d, pname %d, params %p\n", array, pname, params );
    if ((status = UNIX_CALL( glGetArrayObjectfvATI, &args ))) WARN( "glGetArrayObjectfvATI returned %#lx\n", status );
}

static void WINAPI glGetArrayObjectivATI( GLenum array, GLenum pname, GLint *params )
{
    struct glGetArrayObjectivATI_params args = { .teb = NtCurrentTeb(), .array = array, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "array %d, pname %d, params %p\n", array, pname, params );
    if ((status = UNIX_CALL( glGetArrayObjectivATI, &args ))) WARN( "glGetArrayObjectivATI returned %#lx\n", status );
}

static void WINAPI glGetAttachedObjectsARB( GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj )
{
    struct glGetAttachedObjectsARB_params args = { .teb = NtCurrentTeb(), .containerObj = containerObj, .maxCount = maxCount, .count = count, .obj = obj };
    NTSTATUS status;
    TRACE( "containerObj %d, maxCount %d, count %p, obj %p\n", containerObj, maxCount, count, obj );
    if ((status = UNIX_CALL( glGetAttachedObjectsARB, &args ))) WARN( "glGetAttachedObjectsARB returned %#lx\n", status );
}

static void WINAPI glGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders )
{
    struct glGetAttachedShaders_params args = { .teb = NtCurrentTeb(), .program = program, .maxCount = maxCount, .count = count, .shaders = shaders };
    NTSTATUS status;
    TRACE( "program %d, maxCount %d, count %p, shaders %p\n", program, maxCount, count, shaders );
    if ((status = UNIX_CALL( glGetAttachedShaders, &args ))) WARN( "glGetAttachedShaders returned %#lx\n", status );
}

static GLint WINAPI glGetAttribLocation( GLuint program, const GLchar *name )
{
    struct glGetAttribLocation_params args = { .teb = NtCurrentTeb(), .program = program, .name = name };
    NTSTATUS status;
    TRACE( "program %d, name %p\n", program, name );
    if ((status = UNIX_CALL( glGetAttribLocation, &args ))) WARN( "glGetAttribLocation returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glGetAttribLocationARB( GLhandleARB programObj, const GLcharARB *name )
{
    struct glGetAttribLocationARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj, .name = name };
    NTSTATUS status;
    TRACE( "programObj %d, name %p\n", programObj, name );
    if ((status = UNIX_CALL( glGetAttribLocationARB, &args ))) WARN( "glGetAttribLocationARB returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetBooleanIndexedvEXT( GLenum target, GLuint index, GLboolean *data )
{
    struct glGetBooleanIndexedvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetBooleanIndexedvEXT, &args ))) WARN( "glGetBooleanIndexedvEXT returned %#lx\n", status );
}

static void WINAPI glGetBooleani_v( GLenum target, GLuint index, GLboolean *data )
{
    struct glGetBooleani_v_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetBooleani_v, &args ))) WARN( "glGetBooleani_v returned %#lx\n", status );
}

static void WINAPI glGetBufferParameteri64v( GLenum target, GLenum pname, GLint64 *params )
{
    struct glGetBufferParameteri64v_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetBufferParameteri64v, &args ))) WARN( "glGetBufferParameteri64v returned %#lx\n", status );
}

static void WINAPI glGetBufferParameteriv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetBufferParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetBufferParameteriv, &args ))) WARN( "glGetBufferParameteriv returned %#lx\n", status );
}

static void WINAPI glGetBufferParameterivARB( GLenum target, GLenum pname, GLint *params )
{
    struct glGetBufferParameterivARB_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetBufferParameterivARB, &args ))) WARN( "glGetBufferParameterivARB returned %#lx\n", status );
}

static void WINAPI glGetBufferParameterui64vNV( GLenum target, GLenum pname, GLuint64EXT *params )
{
    struct glGetBufferParameterui64vNV_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetBufferParameterui64vNV, &args ))) WARN( "glGetBufferParameterui64vNV returned %#lx\n", status );
}

static void WINAPI glGetBufferPointerv( GLenum target, GLenum pname, void **params )
{
    struct glGetBufferPointerv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetBufferPointerv, &args ))) WARN( "glGetBufferPointerv returned %#lx\n", status );
}

static void WINAPI glGetBufferPointervARB( GLenum target, GLenum pname, void **params )
{
    struct glGetBufferPointervARB_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetBufferPointervARB, &args ))) WARN( "glGetBufferPointervARB returned %#lx\n", status );
}

static void WINAPI glGetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, void *data )
{
    struct glGetBufferSubData_params args = { .teb = NtCurrentTeb(), .target = target, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "target %d, offset %Id, size %Id, data %p\n", target, offset, size, data );
    if ((status = UNIX_CALL( glGetBufferSubData, &args ))) WARN( "glGetBufferSubData returned %#lx\n", status );
}

static void WINAPI glGetBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data )
{
    struct glGetBufferSubDataARB_params args = { .teb = NtCurrentTeb(), .target = target, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "target %d, offset %Id, size %Id, data %p\n", target, offset, size, data );
    if ((status = UNIX_CALL( glGetBufferSubDataARB, &args ))) WARN( "glGetBufferSubDataARB returned %#lx\n", status );
}

static void WINAPI glGetClipPlanefOES( GLenum plane, GLfloat *equation )
{
    struct glGetClipPlanefOES_params args = { .teb = NtCurrentTeb(), .plane = plane, .equation = equation };
    NTSTATUS status;
    TRACE( "plane %d, equation %p\n", plane, equation );
    if ((status = UNIX_CALL( glGetClipPlanefOES, &args ))) WARN( "glGetClipPlanefOES returned %#lx\n", status );
}

static void WINAPI glGetClipPlanexOES( GLenum plane, GLfixed *equation )
{
    struct glGetClipPlanexOES_params args = { .teb = NtCurrentTeb(), .plane = plane, .equation = equation };
    NTSTATUS status;
    TRACE( "plane %d, equation %p\n", plane, equation );
    if ((status = UNIX_CALL( glGetClipPlanexOES, &args ))) WARN( "glGetClipPlanexOES returned %#lx\n", status );
}

static void WINAPI glGetColorTable( GLenum target, GLenum format, GLenum type, void *table )
{
    struct glGetColorTable_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .table = table };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, table %p\n", target, format, type, table );
    if ((status = UNIX_CALL( glGetColorTable, &args ))) WARN( "glGetColorTable returned %#lx\n", status );
}

static void WINAPI glGetColorTableEXT( GLenum target, GLenum format, GLenum type, void *data )
{
    struct glGetColorTableEXT_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .data = data };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, data %p\n", target, format, type, data );
    if ((status = UNIX_CALL( glGetColorTableEXT, &args ))) WARN( "glGetColorTableEXT returned %#lx\n", status );
}

static void WINAPI glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetColorTableParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetColorTableParameterfv, &args ))) WARN( "glGetColorTableParameterfv returned %#lx\n", status );
}

static void WINAPI glGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetColorTableParameterfvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetColorTableParameterfvEXT, &args ))) WARN( "glGetColorTableParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetColorTableParameterfvSGI_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetColorTableParameterfvSGI, &args ))) WARN( "glGetColorTableParameterfvSGI returned %#lx\n", status );
}

static void WINAPI glGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetColorTableParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetColorTableParameteriv, &args ))) WARN( "glGetColorTableParameteriv returned %#lx\n", status );
}

static void WINAPI glGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params )
{
    struct glGetColorTableParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetColorTableParameterivEXT, &args ))) WARN( "glGetColorTableParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetColorTableParameterivSGI( GLenum target, GLenum pname, GLint *params )
{
    struct glGetColorTableParameterivSGI_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetColorTableParameterivSGI, &args ))) WARN( "glGetColorTableParameterivSGI returned %#lx\n", status );
}

static void WINAPI glGetColorTableSGI( GLenum target, GLenum format, GLenum type, void *table )
{
    struct glGetColorTableSGI_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .table = table };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, table %p\n", target, format, type, table );
    if ((status = UNIX_CALL( glGetColorTableSGI, &args ))) WARN( "glGetColorTableSGI returned %#lx\n", status );
}

static void WINAPI glGetCombinerInputParameterfvNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params )
{
    struct glGetCombinerInputParameterfvNV_params args = { .teb = NtCurrentTeb(), .stage = stage, .portion = portion, .variable = variable, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "stage %d, portion %d, variable %d, pname %d, params %p\n", stage, portion, variable, pname, params );
    if ((status = UNIX_CALL( glGetCombinerInputParameterfvNV, &args ))) WARN( "glGetCombinerInputParameterfvNV returned %#lx\n", status );
}

static void WINAPI glGetCombinerInputParameterivNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params )
{
    struct glGetCombinerInputParameterivNV_params args = { .teb = NtCurrentTeb(), .stage = stage, .portion = portion, .variable = variable, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "stage %d, portion %d, variable %d, pname %d, params %p\n", stage, portion, variable, pname, params );
    if ((status = UNIX_CALL( glGetCombinerInputParameterivNV, &args ))) WARN( "glGetCombinerInputParameterivNV returned %#lx\n", status );
}

static void WINAPI glGetCombinerOutputParameterfvNV( GLenum stage, GLenum portion, GLenum pname, GLfloat *params )
{
    struct glGetCombinerOutputParameterfvNV_params args = { .teb = NtCurrentTeb(), .stage = stage, .portion = portion, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "stage %d, portion %d, pname %d, params %p\n", stage, portion, pname, params );
    if ((status = UNIX_CALL( glGetCombinerOutputParameterfvNV, &args ))) WARN( "glGetCombinerOutputParameterfvNV returned %#lx\n", status );
}

static void WINAPI glGetCombinerOutputParameterivNV( GLenum stage, GLenum portion, GLenum pname, GLint *params )
{
    struct glGetCombinerOutputParameterivNV_params args = { .teb = NtCurrentTeb(), .stage = stage, .portion = portion, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "stage %d, portion %d, pname %d, params %p\n", stage, portion, pname, params );
    if ((status = UNIX_CALL( glGetCombinerOutputParameterivNV, &args ))) WARN( "glGetCombinerOutputParameterivNV returned %#lx\n", status );
}

static void WINAPI glGetCombinerStageParameterfvNV( GLenum stage, GLenum pname, GLfloat *params )
{
    struct glGetCombinerStageParameterfvNV_params args = { .teb = NtCurrentTeb(), .stage = stage, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "stage %d, pname %d, params %p\n", stage, pname, params );
    if ((status = UNIX_CALL( glGetCombinerStageParameterfvNV, &args ))) WARN( "glGetCombinerStageParameterfvNV returned %#lx\n", status );
}

static GLuint WINAPI glGetCommandHeaderNV( GLenum tokenID, GLuint size )
{
    struct glGetCommandHeaderNV_params args = { .teb = NtCurrentTeb(), .tokenID = tokenID, .size = size };
    NTSTATUS status;
    TRACE( "tokenID %d, size %d\n", tokenID, size );
    if ((status = UNIX_CALL( glGetCommandHeaderNV, &args ))) WARN( "glGetCommandHeaderNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetCompressedMultiTexImageEXT( GLenum texunit, GLenum target, GLint lod, void *img )
{
    struct glGetCompressedMultiTexImageEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .lod = lod, .img = img };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, lod %d, img %p\n", texunit, target, lod, img );
    if ((status = UNIX_CALL( glGetCompressedMultiTexImageEXT, &args ))) WARN( "glGetCompressedMultiTexImageEXT returned %#lx\n", status );
}

static void WINAPI glGetCompressedTexImage( GLenum target, GLint level, void *img )
{
    struct glGetCompressedTexImage_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .img = img };
    NTSTATUS status;
    TRACE( "target %d, level %d, img %p\n", target, level, img );
    if ((status = UNIX_CALL( glGetCompressedTexImage, &args ))) WARN( "glGetCompressedTexImage returned %#lx\n", status );
}

static void WINAPI glGetCompressedTexImageARB( GLenum target, GLint level, void *img )
{
    struct glGetCompressedTexImageARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .img = img };
    NTSTATUS status;
    TRACE( "target %d, level %d, img %p\n", target, level, img );
    if ((status = UNIX_CALL( glGetCompressedTexImageARB, &args ))) WARN( "glGetCompressedTexImageARB returned %#lx\n", status );
}

static void WINAPI glGetCompressedTextureImage( GLuint texture, GLint level, GLsizei bufSize, void *pixels )
{
    struct glGetCompressedTextureImage_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .bufSize = bufSize, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, level %d, bufSize %d, pixels %p\n", texture, level, bufSize, pixels );
    if ((status = UNIX_CALL( glGetCompressedTextureImage, &args ))) WARN( "glGetCompressedTextureImage returned %#lx\n", status );
}

static void WINAPI glGetCompressedTextureImageEXT( GLuint texture, GLenum target, GLint lod, void *img )
{
    struct glGetCompressedTextureImageEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .lod = lod, .img = img };
    NTSTATUS status;
    TRACE( "texture %d, target %d, lod %d, img %p\n", texture, target, lod, img );
    if ((status = UNIX_CALL( glGetCompressedTextureImageEXT, &args ))) WARN( "glGetCompressedTextureImageEXT returned %#lx\n", status );
}

static void WINAPI glGetCompressedTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels )
{
    struct glGetCompressedTextureSubImage_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .bufSize = bufSize, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, bufSize %d, pixels %p\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels );
    if ((status = UNIX_CALL( glGetCompressedTextureSubImage, &args ))) WARN( "glGetCompressedTextureSubImage returned %#lx\n", status );
}

static void WINAPI glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, void *image )
{
    struct glGetConvolutionFilter_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .image = image };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, image %p\n", target, format, type, image );
    if ((status = UNIX_CALL( glGetConvolutionFilter, &args ))) WARN( "glGetConvolutionFilter returned %#lx\n", status );
}

static void WINAPI glGetConvolutionFilterEXT( GLenum target, GLenum format, GLenum type, void *image )
{
    struct glGetConvolutionFilterEXT_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .image = image };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, image %p\n", target, format, type, image );
    if ((status = UNIX_CALL( glGetConvolutionFilterEXT, &args ))) WARN( "glGetConvolutionFilterEXT returned %#lx\n", status );
}

static void WINAPI glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetConvolutionParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetConvolutionParameterfv, &args ))) WARN( "glGetConvolutionParameterfv returned %#lx\n", status );
}

static void WINAPI glGetConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetConvolutionParameterfvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetConvolutionParameterfvEXT, &args ))) WARN( "glGetConvolutionParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetConvolutionParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetConvolutionParameteriv, &args ))) WARN( "glGetConvolutionParameteriv returned %#lx\n", status );
}

static void WINAPI glGetConvolutionParameterivEXT( GLenum target, GLenum pname, GLint *params )
{
    struct glGetConvolutionParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetConvolutionParameterivEXT, &args ))) WARN( "glGetConvolutionParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetConvolutionParameterxvOES( GLenum target, GLenum pname, GLfixed *params )
{
    struct glGetConvolutionParameterxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetConvolutionParameterxvOES, &args ))) WARN( "glGetConvolutionParameterxvOES returned %#lx\n", status );
}

static void WINAPI glGetCoverageModulationTableNV( GLsizei bufSize, GLfloat *v )
{
    struct glGetCoverageModulationTableNV_params args = { .teb = NtCurrentTeb(), .bufSize = bufSize, .v = v };
    NTSTATUS status;
    TRACE( "bufSize %d, v %p\n", bufSize, v );
    if ((status = UNIX_CALL( glGetCoverageModulationTableNV, &args ))) WARN( "glGetCoverageModulationTableNV returned %#lx\n", status );
}

static GLuint WINAPI glGetDebugMessageLog( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog )
{
    struct glGetDebugMessageLog_params args = { .teb = NtCurrentTeb(), .count = count, .bufSize = bufSize, .sources = sources, .types = types, .ids = ids, .severities = severities, .lengths = lengths, .messageLog = messageLog };
    NTSTATUS status;
    TRACE( "count %d, bufSize %d, sources %p, types %p, ids %p, severities %p, lengths %p, messageLog %p\n", count, bufSize, sources, types, ids, severities, lengths, messageLog );
    if ((status = UNIX_CALL( glGetDebugMessageLog, &args ))) WARN( "glGetDebugMessageLog returned %#lx\n", status );
    return args.ret;
}

static GLuint WINAPI glGetDebugMessageLogAMD( GLuint count, GLsizei bufSize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message )
{
    struct glGetDebugMessageLogAMD_params args = { .teb = NtCurrentTeb(), .count = count, .bufSize = bufSize, .categories = categories, .severities = severities, .ids = ids, .lengths = lengths, .message = message };
    NTSTATUS status;
    TRACE( "count %d, bufSize %d, categories %p, severities %p, ids %p, lengths %p, message %p\n", count, bufSize, categories, severities, ids, lengths, message );
    if ((status = UNIX_CALL( glGetDebugMessageLogAMD, &args ))) WARN( "glGetDebugMessageLogAMD returned %#lx\n", status );
    return args.ret;
}

static GLuint WINAPI glGetDebugMessageLogARB( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog )
{
    struct glGetDebugMessageLogARB_params args = { .teb = NtCurrentTeb(), .count = count, .bufSize = bufSize, .sources = sources, .types = types, .ids = ids, .severities = severities, .lengths = lengths, .messageLog = messageLog };
    NTSTATUS status;
    TRACE( "count %d, bufSize %d, sources %p, types %p, ids %p, severities %p, lengths %p, messageLog %p\n", count, bufSize, sources, types, ids, severities, lengths, messageLog );
    if ((status = UNIX_CALL( glGetDebugMessageLogARB, &args ))) WARN( "glGetDebugMessageLogARB returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetDetailTexFuncSGIS( GLenum target, GLfloat *points )
{
    struct glGetDetailTexFuncSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .points = points };
    NTSTATUS status;
    TRACE( "target %d, points %p\n", target, points );
    if ((status = UNIX_CALL( glGetDetailTexFuncSGIS, &args ))) WARN( "glGetDetailTexFuncSGIS returned %#lx\n", status );
}

static void WINAPI glGetDoubleIndexedvEXT( GLenum target, GLuint index, GLdouble *data )
{
    struct glGetDoubleIndexedvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetDoubleIndexedvEXT, &args ))) WARN( "glGetDoubleIndexedvEXT returned %#lx\n", status );
}

static void WINAPI glGetDoublei_v( GLenum target, GLuint index, GLdouble *data )
{
    struct glGetDoublei_v_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetDoublei_v, &args ))) WARN( "glGetDoublei_v returned %#lx\n", status );
}

static void WINAPI glGetDoublei_vEXT( GLenum pname, GLuint index, GLdouble *params )
{
    struct glGetDoublei_vEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, index %d, params %p\n", pname, index, params );
    if ((status = UNIX_CALL( glGetDoublei_vEXT, &args ))) WARN( "glGetDoublei_vEXT returned %#lx\n", status );
}

static void WINAPI glGetFenceivNV( GLuint fence, GLenum pname, GLint *params )
{
    struct glGetFenceivNV_params args = { .teb = NtCurrentTeb(), .fence = fence, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "fence %d, pname %d, params %p\n", fence, pname, params );
    if ((status = UNIX_CALL( glGetFenceivNV, &args ))) WARN( "glGetFenceivNV returned %#lx\n", status );
}

static void WINAPI glGetFinalCombinerInputParameterfvNV( GLenum variable, GLenum pname, GLfloat *params )
{
    struct glGetFinalCombinerInputParameterfvNV_params args = { .teb = NtCurrentTeb(), .variable = variable, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "variable %d, pname %d, params %p\n", variable, pname, params );
    if ((status = UNIX_CALL( glGetFinalCombinerInputParameterfvNV, &args ))) WARN( "glGetFinalCombinerInputParameterfvNV returned %#lx\n", status );
}

static void WINAPI glGetFinalCombinerInputParameterivNV( GLenum variable, GLenum pname, GLint *params )
{
    struct glGetFinalCombinerInputParameterivNV_params args = { .teb = NtCurrentTeb(), .variable = variable, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "variable %d, pname %d, params %p\n", variable, pname, params );
    if ((status = UNIX_CALL( glGetFinalCombinerInputParameterivNV, &args ))) WARN( "glGetFinalCombinerInputParameterivNV returned %#lx\n", status );
}

static void WINAPI glGetFirstPerfQueryIdINTEL( GLuint *queryId )
{
    struct glGetFirstPerfQueryIdINTEL_params args = { .teb = NtCurrentTeb(), .queryId = queryId };
    NTSTATUS status;
    TRACE( "queryId %p\n", queryId );
    if ((status = UNIX_CALL( glGetFirstPerfQueryIdINTEL, &args ))) WARN( "glGetFirstPerfQueryIdINTEL returned %#lx\n", status );
}

static void WINAPI glGetFixedvOES( GLenum pname, GLfixed *params )
{
    struct glGetFixedvOES_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glGetFixedvOES, &args ))) WARN( "glGetFixedvOES returned %#lx\n", status );
}

static void WINAPI glGetFloatIndexedvEXT( GLenum target, GLuint index, GLfloat *data )
{
    struct glGetFloatIndexedvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetFloatIndexedvEXT, &args ))) WARN( "glGetFloatIndexedvEXT returned %#lx\n", status );
}

static void WINAPI glGetFloati_v( GLenum target, GLuint index, GLfloat *data )
{
    struct glGetFloati_v_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetFloati_v, &args ))) WARN( "glGetFloati_v returned %#lx\n", status );
}

static void WINAPI glGetFloati_vEXT( GLenum pname, GLuint index, GLfloat *params )
{
    struct glGetFloati_vEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, index %d, params %p\n", pname, index, params );
    if ((status = UNIX_CALL( glGetFloati_vEXT, &args ))) WARN( "glGetFloati_vEXT returned %#lx\n", status );
}

static void WINAPI glGetFogFuncSGIS( GLfloat *points )
{
    struct glGetFogFuncSGIS_params args = { .teb = NtCurrentTeb(), .points = points };
    NTSTATUS status;
    TRACE( "points %p\n", points );
    if ((status = UNIX_CALL( glGetFogFuncSGIS, &args ))) WARN( "glGetFogFuncSGIS returned %#lx\n", status );
}

static GLint WINAPI glGetFragDataIndex( GLuint program, const GLchar *name )
{
    struct glGetFragDataIndex_params args = { .teb = NtCurrentTeb(), .program = program, .name = name };
    NTSTATUS status;
    TRACE( "program %d, name %p\n", program, name );
    if ((status = UNIX_CALL( glGetFragDataIndex, &args ))) WARN( "glGetFragDataIndex returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glGetFragDataLocation( GLuint program, const GLchar *name )
{
    struct glGetFragDataLocation_params args = { .teb = NtCurrentTeb(), .program = program, .name = name };
    NTSTATUS status;
    TRACE( "program %d, name %p\n", program, name );
    if ((status = UNIX_CALL( glGetFragDataLocation, &args ))) WARN( "glGetFragDataLocation returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glGetFragDataLocationEXT( GLuint program, const GLchar *name )
{
    struct glGetFragDataLocationEXT_params args = { .teb = NtCurrentTeb(), .program = program, .name = name };
    NTSTATUS status;
    TRACE( "program %d, name %p\n", program, name );
    if ((status = UNIX_CALL( glGetFragDataLocationEXT, &args ))) WARN( "glGetFragDataLocationEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat *params )
{
    struct glGetFragmentLightfvSGIX_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glGetFragmentLightfvSGIX, &args ))) WARN( "glGetFragmentLightfvSGIX returned %#lx\n", status );
}

static void WINAPI glGetFragmentLightivSGIX( GLenum light, GLenum pname, GLint *params )
{
    struct glGetFragmentLightivSGIX_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glGetFragmentLightivSGIX, &args ))) WARN( "glGetFragmentLightivSGIX returned %#lx\n", status );
}

static void WINAPI glGetFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat *params )
{
    struct glGetFragmentMaterialfvSGIX_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
    if ((status = UNIX_CALL( glGetFragmentMaterialfvSGIX, &args ))) WARN( "glGetFragmentMaterialfvSGIX returned %#lx\n", status );
}

static void WINAPI glGetFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint *params )
{
    struct glGetFragmentMaterialivSGIX_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
    if ((status = UNIX_CALL( glGetFragmentMaterialivSGIX, &args ))) WARN( "glGetFragmentMaterialivSGIX returned %#lx\n", status );
}

static void WINAPI glGetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint *params )
{
    struct glGetFramebufferAttachmentParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, pname %d, params %p\n", target, attachment, pname, params );
    if ((status = UNIX_CALL( glGetFramebufferAttachmentParameteriv, &args ))) WARN( "glGetFramebufferAttachmentParameteriv returned %#lx\n", status );
}

static void WINAPI glGetFramebufferAttachmentParameterivEXT( GLenum target, GLenum attachment, GLenum pname, GLint *params )
{
    struct glGetFramebufferAttachmentParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .attachment = attachment, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, attachment %d, pname %d, params %p\n", target, attachment, pname, params );
    if ((status = UNIX_CALL( glGetFramebufferAttachmentParameterivEXT, &args ))) WARN( "glGetFramebufferAttachmentParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetFramebufferParameterfvAMD( GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values )
{
    struct glGetFramebufferParameterfvAMD_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .numsamples = numsamples, .pixelindex = pixelindex, .size = size, .values = values };
    NTSTATUS status;
    TRACE( "target %d, pname %d, numsamples %d, pixelindex %d, size %d, values %p\n", target, pname, numsamples, pixelindex, size, values );
    if ((status = UNIX_CALL( glGetFramebufferParameterfvAMD, &args ))) WARN( "glGetFramebufferParameterfvAMD returned %#lx\n", status );
}

static void WINAPI glGetFramebufferParameteriv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetFramebufferParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetFramebufferParameteriv, &args ))) WARN( "glGetFramebufferParameteriv returned %#lx\n", status );
}

static void WINAPI glGetFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint *params )
{
    struct glGetFramebufferParameterivEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "framebuffer %d, pname %d, params %p\n", framebuffer, pname, params );
    if ((status = UNIX_CALL( glGetFramebufferParameterivEXT, &args ))) WARN( "glGetFramebufferParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetFramebufferParameterivMESA( GLenum target, GLenum pname, GLint *params )
{
    struct glGetFramebufferParameterivMESA_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetFramebufferParameterivMESA, &args ))) WARN( "glGetFramebufferParameterivMESA returned %#lx\n", status );
}

static GLenum WINAPI glGetGraphicsResetStatus(void)
{
    struct glGetGraphicsResetStatus_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glGetGraphicsResetStatus, &args ))) WARN( "glGetGraphicsResetStatus returned %#lx\n", status );
    return args.ret;
}

static GLenum WINAPI glGetGraphicsResetStatusARB(void)
{
    struct glGetGraphicsResetStatusARB_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glGetGraphicsResetStatusARB, &args ))) WARN( "glGetGraphicsResetStatusARB returned %#lx\n", status );
    return args.ret;
}

static GLhandleARB WINAPI glGetHandleARB( GLenum pname )
{
    struct glGetHandleARB_params args = { .teb = NtCurrentTeb(), .pname = pname };
    NTSTATUS status;
    TRACE( "pname %d\n", pname );
    if ((status = UNIX_CALL( glGetHandleARB, &args ))) WARN( "glGetHandleARB returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values )
{
    struct glGetHistogram_params args = { .teb = NtCurrentTeb(), .target = target, .reset = reset, .format = format, .type = type, .values = values };
    NTSTATUS status;
    TRACE( "target %d, reset %d, format %d, type %d, values %p\n", target, reset, format, type, values );
    if ((status = UNIX_CALL( glGetHistogram, &args ))) WARN( "glGetHistogram returned %#lx\n", status );
}

static void WINAPI glGetHistogramEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values )
{
    struct glGetHistogramEXT_params args = { .teb = NtCurrentTeb(), .target = target, .reset = reset, .format = format, .type = type, .values = values };
    NTSTATUS status;
    TRACE( "target %d, reset %d, format %d, type %d, values %p\n", target, reset, format, type, values );
    if ((status = UNIX_CALL( glGetHistogramEXT, &args ))) WARN( "glGetHistogramEXT returned %#lx\n", status );
}

static void WINAPI glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetHistogramParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetHistogramParameterfv, &args ))) WARN( "glGetHistogramParameterfv returned %#lx\n", status );
}

static void WINAPI glGetHistogramParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetHistogramParameterfvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetHistogramParameterfvEXT, &args ))) WARN( "glGetHistogramParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetHistogramParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetHistogramParameteriv, &args ))) WARN( "glGetHistogramParameteriv returned %#lx\n", status );
}

static void WINAPI glGetHistogramParameterivEXT( GLenum target, GLenum pname, GLint *params )
{
    struct glGetHistogramParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetHistogramParameterivEXT, &args ))) WARN( "glGetHistogramParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetHistogramParameterxvOES( GLenum target, GLenum pname, GLfixed *params )
{
    struct glGetHistogramParameterxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetHistogramParameterxvOES, &args ))) WARN( "glGetHistogramParameterxvOES returned %#lx\n", status );
}

static GLuint64 WINAPI glGetImageHandleARB( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format )
{
    struct glGetImageHandleARB_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .layered = layered, .layer = layer, .format = format };
    NTSTATUS status;
    TRACE( "texture %d, level %d, layered %d, layer %d, format %d\n", texture, level, layered, layer, format );
    if ((status = UNIX_CALL( glGetImageHandleARB, &args ))) WARN( "glGetImageHandleARB returned %#lx\n", status );
    return args.ret;
}

static GLuint64 WINAPI glGetImageHandleNV( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format )
{
    struct glGetImageHandleNV_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .layered = layered, .layer = layer, .format = format };
    NTSTATUS status;
    TRACE( "texture %d, level %d, layered %d, layer %d, format %d\n", texture, level, layered, layer, format );
    if ((status = UNIX_CALL( glGetImageHandleNV, &args ))) WARN( "glGetImageHandleNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetImageTransformParameterfvHP_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetImageTransformParameterfvHP, &args ))) WARN( "glGetImageTransformParameterfvHP returned %#lx\n", status );
}

static void WINAPI glGetImageTransformParameterivHP( GLenum target, GLenum pname, GLint *params )
{
    struct glGetImageTransformParameterivHP_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetImageTransformParameterivHP, &args ))) WARN( "glGetImageTransformParameterivHP returned %#lx\n", status );
}

static void WINAPI glGetInfoLogARB( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog )
{
    struct glGetInfoLogARB_params args = { .teb = NtCurrentTeb(), .obj = obj, .maxLength = maxLength, .length = length, .infoLog = infoLog };
    NTSTATUS status;
    TRACE( "obj %d, maxLength %d, length %p, infoLog %p\n", obj, maxLength, length, infoLog );
    if ((status = UNIX_CALL( glGetInfoLogARB, &args ))) WARN( "glGetInfoLogARB returned %#lx\n", status );
}

static GLint WINAPI glGetInstrumentsSGIX(void)
{
    struct glGetInstrumentsSGIX_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glGetInstrumentsSGIX, &args ))) WARN( "glGetInstrumentsSGIX returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetInteger64i_v( GLenum target, GLuint index, GLint64 *data )
{
    struct glGetInteger64i_v_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetInteger64i_v, &args ))) WARN( "glGetInteger64i_v returned %#lx\n", status );
}

static void WINAPI glGetInteger64v( GLenum pname, GLint64 *data )
{
    struct glGetInteger64v_params args = { .teb = NtCurrentTeb(), .pname = pname, .data = data };
    NTSTATUS status;
    TRACE( "pname %d, data %p\n", pname, data );
    if ((status = UNIX_CALL( glGetInteger64v, &args ))) WARN( "glGetInteger64v returned %#lx\n", status );
}

static void WINAPI glGetIntegerIndexedvEXT( GLenum target, GLuint index, GLint *data )
{
    struct glGetIntegerIndexedvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetIntegerIndexedvEXT, &args ))) WARN( "glGetIntegerIndexedvEXT returned %#lx\n", status );
}

static void WINAPI glGetIntegeri_v( GLenum target, GLuint index, GLint *data )
{
    struct glGetIntegeri_v_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetIntegeri_v, &args ))) WARN( "glGetIntegeri_v returned %#lx\n", status );
}

static void WINAPI glGetIntegerui64i_vNV( GLenum value, GLuint index, GLuint64EXT *result )
{
    struct glGetIntegerui64i_vNV_params args = { .teb = NtCurrentTeb(), .value = value, .index = index, .result = result };
    NTSTATUS status;
    TRACE( "value %d, index %d, result %p\n", value, index, result );
    if ((status = UNIX_CALL( glGetIntegerui64i_vNV, &args ))) WARN( "glGetIntegerui64i_vNV returned %#lx\n", status );
}

static void WINAPI glGetIntegerui64vNV( GLenum value, GLuint64EXT *result )
{
    struct glGetIntegerui64vNV_params args = { .teb = NtCurrentTeb(), .value = value, .result = result };
    NTSTATUS status;
    TRACE( "value %d, result %p\n", value, result );
    if ((status = UNIX_CALL( glGetIntegerui64vNV, &args ))) WARN( "glGetIntegerui64vNV returned %#lx\n", status );
}

static void WINAPI glGetInternalformatSampleivNV( GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei count, GLint *params )
{
    struct glGetInternalformatSampleivNV_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .samples = samples, .pname = pname, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, samples %d, pname %d, count %d, params %p\n", target, internalformat, samples, pname, count, params );
    if ((status = UNIX_CALL( glGetInternalformatSampleivNV, &args ))) WARN( "glGetInternalformatSampleivNV returned %#lx\n", status );
}

static void WINAPI glGetInternalformati64v( GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint64 *params )
{
    struct glGetInternalformati64v_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .pname = pname, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, pname %d, count %d, params %p\n", target, internalformat, pname, count, params );
    if ((status = UNIX_CALL( glGetInternalformati64v, &args ))) WARN( "glGetInternalformati64v returned %#lx\n", status );
}

static void WINAPI glGetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint *params )
{
    struct glGetInternalformativ_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .pname = pname, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, pname %d, count %d, params %p\n", target, internalformat, pname, count, params );
    if ((status = UNIX_CALL( glGetInternalformativ, &args ))) WARN( "glGetInternalformativ returned %#lx\n", status );
}

static void WINAPI glGetInvariantBooleanvEXT( GLuint id, GLenum value, GLboolean *data )
{
    struct glGetInvariantBooleanvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetInvariantBooleanvEXT, &args ))) WARN( "glGetInvariantBooleanvEXT returned %#lx\n", status );
}

static void WINAPI glGetInvariantFloatvEXT( GLuint id, GLenum value, GLfloat *data )
{
    struct glGetInvariantFloatvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetInvariantFloatvEXT, &args ))) WARN( "glGetInvariantFloatvEXT returned %#lx\n", status );
}

static void WINAPI glGetInvariantIntegervEXT( GLuint id, GLenum value, GLint *data )
{
    struct glGetInvariantIntegervEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetInvariantIntegervEXT, &args ))) WARN( "glGetInvariantIntegervEXT returned %#lx\n", status );
}

static void WINAPI glGetLightxOES( GLenum light, GLenum pname, GLfixed *params )
{
    struct glGetLightxOES_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glGetLightxOES, &args ))) WARN( "glGetLightxOES returned %#lx\n", status );
}

static void WINAPI glGetListParameterfvSGIX( GLuint list, GLenum pname, GLfloat *params )
{
    struct glGetListParameterfvSGIX_params args = { .teb = NtCurrentTeb(), .list = list, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "list %d, pname %d, params %p\n", list, pname, params );
    if ((status = UNIX_CALL( glGetListParameterfvSGIX, &args ))) WARN( "glGetListParameterfvSGIX returned %#lx\n", status );
}

static void WINAPI glGetListParameterivSGIX( GLuint list, GLenum pname, GLint *params )
{
    struct glGetListParameterivSGIX_params args = { .teb = NtCurrentTeb(), .list = list, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "list %d, pname %d, params %p\n", list, pname, params );
    if ((status = UNIX_CALL( glGetListParameterivSGIX, &args ))) WARN( "glGetListParameterivSGIX returned %#lx\n", status );
}

static void WINAPI glGetLocalConstantBooleanvEXT( GLuint id, GLenum value, GLboolean *data )
{
    struct glGetLocalConstantBooleanvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetLocalConstantBooleanvEXT, &args ))) WARN( "glGetLocalConstantBooleanvEXT returned %#lx\n", status );
}

static void WINAPI glGetLocalConstantFloatvEXT( GLuint id, GLenum value, GLfloat *data )
{
    struct glGetLocalConstantFloatvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetLocalConstantFloatvEXT, &args ))) WARN( "glGetLocalConstantFloatvEXT returned %#lx\n", status );
}

static void WINAPI glGetLocalConstantIntegervEXT( GLuint id, GLenum value, GLint *data )
{
    struct glGetLocalConstantIntegervEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetLocalConstantIntegervEXT, &args ))) WARN( "glGetLocalConstantIntegervEXT returned %#lx\n", status );
}

static void WINAPI glGetMapAttribParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat *params )
{
    struct glGetMapAttribParameterfvNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, pname %d, params %p\n", target, index, pname, params );
    if ((status = UNIX_CALL( glGetMapAttribParameterfvNV, &args ))) WARN( "glGetMapAttribParameterfvNV returned %#lx\n", status );
}

static void WINAPI glGetMapAttribParameterivNV( GLenum target, GLuint index, GLenum pname, GLint *params )
{
    struct glGetMapAttribParameterivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, pname %d, params %p\n", target, index, pname, params );
    if ((status = UNIX_CALL( glGetMapAttribParameterivNV, &args ))) WARN( "glGetMapAttribParameterivNV returned %#lx\n", status );
}

static void WINAPI glGetMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void *points )
{
    struct glGetMapControlPointsNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .type = type, .ustride = ustride, .vstride = vstride, .packed = packed, .points = points };
    NTSTATUS status;
    TRACE( "target %d, index %d, type %d, ustride %d, vstride %d, packed %d, points %p\n", target, index, type, ustride, vstride, packed, points );
    if ((status = UNIX_CALL( glGetMapControlPointsNV, &args ))) WARN( "glGetMapControlPointsNV returned %#lx\n", status );
}

static void WINAPI glGetMapParameterfvNV( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetMapParameterfvNV_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetMapParameterfvNV, &args ))) WARN( "glGetMapParameterfvNV returned %#lx\n", status );
}

static void WINAPI glGetMapParameterivNV( GLenum target, GLenum pname, GLint *params )
{
    struct glGetMapParameterivNV_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetMapParameterivNV, &args ))) WARN( "glGetMapParameterivNV returned %#lx\n", status );
}

static void WINAPI glGetMapxvOES( GLenum target, GLenum query, GLfixed *v )
{
    struct glGetMapxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, v %p\n", target, query, v );
    if ((status = UNIX_CALL( glGetMapxvOES, &args ))) WARN( "glGetMapxvOES returned %#lx\n", status );
}

static void WINAPI glGetMaterialxOES( GLenum face, GLenum pname, GLfixed param )
{
    struct glGetMaterialxOES_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "face %d, pname %d, param %d\n", face, pname, param );
    if ((status = UNIX_CALL( glGetMaterialxOES, &args ))) WARN( "glGetMaterialxOES returned %#lx\n", status );
}

static void WINAPI glGetMemoryObjectDetachedResourcesuivNV( GLuint memory, GLenum pname, GLint first, GLsizei count, GLuint *params )
{
    struct glGetMemoryObjectDetachedResourcesuivNV_params args = { .teb = NtCurrentTeb(), .memory = memory, .pname = pname, .first = first, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "memory %d, pname %d, first %d, count %d, params %p\n", memory, pname, first, count, params );
    if ((status = UNIX_CALL( glGetMemoryObjectDetachedResourcesuivNV, &args ))) WARN( "glGetMemoryObjectDetachedResourcesuivNV returned %#lx\n", status );
}

static void WINAPI glGetMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, GLint *params )
{
    struct glGetMemoryObjectParameterivEXT_params args = { .teb = NtCurrentTeb(), .memoryObject = memoryObject, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "memoryObject %d, pname %d, params %p\n", memoryObject, pname, params );
    if ((status = UNIX_CALL( glGetMemoryObjectParameterivEXT, &args ))) WARN( "glGetMemoryObjectParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values )
{
    struct glGetMinmax_params args = { .teb = NtCurrentTeb(), .target = target, .reset = reset, .format = format, .type = type, .values = values };
    NTSTATUS status;
    TRACE( "target %d, reset %d, format %d, type %d, values %p\n", target, reset, format, type, values );
    if ((status = UNIX_CALL( glGetMinmax, &args ))) WARN( "glGetMinmax returned %#lx\n", status );
}

static void WINAPI glGetMinmaxEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values )
{
    struct glGetMinmaxEXT_params args = { .teb = NtCurrentTeb(), .target = target, .reset = reset, .format = format, .type = type, .values = values };
    NTSTATUS status;
    TRACE( "target %d, reset %d, format %d, type %d, values %p\n", target, reset, format, type, values );
    if ((status = UNIX_CALL( glGetMinmaxEXT, &args ))) WARN( "glGetMinmaxEXT returned %#lx\n", status );
}

static void WINAPI glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetMinmaxParameterfv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetMinmaxParameterfv, &args ))) WARN( "glGetMinmaxParameterfv returned %#lx\n", status );
}

static void WINAPI glGetMinmaxParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetMinmaxParameterfvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetMinmaxParameterfvEXT, &args ))) WARN( "glGetMinmaxParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetMinmaxParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetMinmaxParameteriv, &args ))) WARN( "glGetMinmaxParameteriv returned %#lx\n", status );
}

static void WINAPI glGetMinmaxParameterivEXT( GLenum target, GLenum pname, GLint *params )
{
    struct glGetMinmaxParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetMinmaxParameterivEXT, &args ))) WARN( "glGetMinmaxParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetMultiTexEnvfvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexEnvfvEXT, &args ))) WARN( "glGetMultiTexEnvfvEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params )
{
    struct glGetMultiTexEnvivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexEnvivEXT, &args ))) WARN( "glGetMultiTexEnvivEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble *params )
{
    struct glGetMultiTexGendvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, params %p\n", texunit, coord, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexGendvEXT, &args ))) WARN( "glGetMultiTexGendvEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat *params )
{
    struct glGetMultiTexGenfvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, params %p\n", texunit, coord, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexGenfvEXT, &args ))) WARN( "glGetMultiTexGenfvEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, GLint *params )
{
    struct glGetMultiTexGenivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, params %p\n", texunit, coord, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexGenivEXT, &args ))) WARN( "glGetMultiTexGenivEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexImageEXT( GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
{
    struct glGetMultiTexImageEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, format %d, type %d, pixels %p\n", texunit, target, level, format, type, pixels );
    if ((status = UNIX_CALL( glGetMultiTexImageEXT, &args ))) WARN( "glGetMultiTexImageEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexLevelParameterfvEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params )
{
    struct glGetMultiTexLevelParameterfvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, pname %d, params %p\n", texunit, target, level, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexLevelParameterfvEXT, &args ))) WARN( "glGetMultiTexLevelParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexLevelParameterivEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params )
{
    struct glGetMultiTexLevelParameterivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, pname %d, params %p\n", texunit, target, level, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexLevelParameterivEXT, &args ))) WARN( "glGetMultiTexLevelParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params )
{
    struct glGetMultiTexParameterIivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexParameterIivEXT, &args ))) WARN( "glGetMultiTexParameterIivEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, GLuint *params )
{
    struct glGetMultiTexParameterIuivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexParameterIuivEXT, &args ))) WARN( "glGetMultiTexParameterIuivEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetMultiTexParameterfvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexParameterfvEXT, &args ))) WARN( "glGetMultiTexParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params )
{
    struct glGetMultiTexParameterivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glGetMultiTexParameterivEXT, &args ))) WARN( "glGetMultiTexParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetMultisamplefv( GLenum pname, GLuint index, GLfloat *val )
{
    struct glGetMultisamplefv_params args = { .teb = NtCurrentTeb(), .pname = pname, .index = index, .val = val };
    NTSTATUS status;
    TRACE( "pname %d, index %d, val %p\n", pname, index, val );
    if ((status = UNIX_CALL( glGetMultisamplefv, &args ))) WARN( "glGetMultisamplefv returned %#lx\n", status );
}

static void WINAPI glGetMultisamplefvNV( GLenum pname, GLuint index, GLfloat *val )
{
    struct glGetMultisamplefvNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .index = index, .val = val };
    NTSTATUS status;
    TRACE( "pname %d, index %d, val %p\n", pname, index, val );
    if ((status = UNIX_CALL( glGetMultisamplefvNV, &args ))) WARN( "glGetMultisamplefvNV returned %#lx\n", status );
}

static void WINAPI glGetNamedBufferParameteri64v( GLuint buffer, GLenum pname, GLint64 *params )
{
    struct glGetNamedBufferParameteri64v_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "buffer %d, pname %d, params %p\n", buffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedBufferParameteri64v, &args ))) WARN( "glGetNamedBufferParameteri64v returned %#lx\n", status );
}

static void WINAPI glGetNamedBufferParameteriv( GLuint buffer, GLenum pname, GLint *params )
{
    struct glGetNamedBufferParameteriv_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "buffer %d, pname %d, params %p\n", buffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedBufferParameteriv, &args ))) WARN( "glGetNamedBufferParameteriv returned %#lx\n", status );
}

static void WINAPI glGetNamedBufferParameterivEXT( GLuint buffer, GLenum pname, GLint *params )
{
    struct glGetNamedBufferParameterivEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "buffer %d, pname %d, params %p\n", buffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedBufferParameterivEXT, &args ))) WARN( "glGetNamedBufferParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedBufferParameterui64vNV( GLuint buffer, GLenum pname, GLuint64EXT *params )
{
    struct glGetNamedBufferParameterui64vNV_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "buffer %d, pname %d, params %p\n", buffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedBufferParameterui64vNV, &args ))) WARN( "glGetNamedBufferParameterui64vNV returned %#lx\n", status );
}

static void WINAPI glGetNamedBufferPointerv( GLuint buffer, GLenum pname, void **params )
{
    struct glGetNamedBufferPointerv_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "buffer %d, pname %d, params %p\n", buffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedBufferPointerv, &args ))) WARN( "glGetNamedBufferPointerv returned %#lx\n", status );
}

static void WINAPI glGetNamedBufferPointervEXT( GLuint buffer, GLenum pname, void **params )
{
    struct glGetNamedBufferPointervEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "buffer %d, pname %d, params %p\n", buffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedBufferPointervEXT, &args ))) WARN( "glGetNamedBufferPointervEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, void *data )
{
    struct glGetNamedBufferSubData_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, size %Id, data %p\n", buffer, offset, size, data );
    if ((status = UNIX_CALL( glGetNamedBufferSubData, &args ))) WARN( "glGetNamedBufferSubData returned %#lx\n", status );
}

static void WINAPI glGetNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, void *data )
{
    struct glGetNamedBufferSubDataEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, size %Id, data %p\n", buffer, offset, size, data );
    if ((status = UNIX_CALL( glGetNamedBufferSubDataEXT, &args ))) WARN( "glGetNamedBufferSubDataEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedFramebufferAttachmentParameteriv( GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params )
{
    struct glGetNamedFramebufferAttachmentParameteriv_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, pname %d, params %p\n", framebuffer, attachment, pname, params );
    if ((status = UNIX_CALL( glGetNamedFramebufferAttachmentParameteriv, &args ))) WARN( "glGetNamedFramebufferAttachmentParameteriv returned %#lx\n", status );
}

static void WINAPI glGetNamedFramebufferAttachmentParameterivEXT( GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params )
{
    struct glGetNamedFramebufferAttachmentParameterivEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, pname %d, params %p\n", framebuffer, attachment, pname, params );
    if ((status = UNIX_CALL( glGetNamedFramebufferAttachmentParameterivEXT, &args ))) WARN( "glGetNamedFramebufferAttachmentParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedFramebufferParameterfvAMD( GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values )
{
    struct glGetNamedFramebufferParameterfvAMD_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .pname = pname, .numsamples = numsamples, .pixelindex = pixelindex, .size = size, .values = values };
    NTSTATUS status;
    TRACE( "framebuffer %d, pname %d, numsamples %d, pixelindex %d, size %d, values %p\n", framebuffer, pname, numsamples, pixelindex, size, values );
    if ((status = UNIX_CALL( glGetNamedFramebufferParameterfvAMD, &args ))) WARN( "glGetNamedFramebufferParameterfvAMD returned %#lx\n", status );
}

static void WINAPI glGetNamedFramebufferParameteriv( GLuint framebuffer, GLenum pname, GLint *param )
{
    struct glGetNamedFramebufferParameteriv_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "framebuffer %d, pname %d, param %p\n", framebuffer, pname, param );
    if ((status = UNIX_CALL( glGetNamedFramebufferParameteriv, &args ))) WARN( "glGetNamedFramebufferParameteriv returned %#lx\n", status );
}

static void WINAPI glGetNamedFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint *params )
{
    struct glGetNamedFramebufferParameterivEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "framebuffer %d, pname %d, params %p\n", framebuffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedFramebufferParameterivEXT, &args ))) WARN( "glGetNamedFramebufferParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedProgramLocalParameterIivEXT( GLuint program, GLenum target, GLuint index, GLint *params )
{
    struct glGetNamedProgramLocalParameterIivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, params %p\n", program, target, index, params );
    if ((status = UNIX_CALL( glGetNamedProgramLocalParameterIivEXT, &args ))) WARN( "glGetNamedProgramLocalParameterIivEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedProgramLocalParameterIuivEXT( GLuint program, GLenum target, GLuint index, GLuint *params )
{
    struct glGetNamedProgramLocalParameterIuivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, params %p\n", program, target, index, params );
    if ((status = UNIX_CALL( glGetNamedProgramLocalParameterIuivEXT, &args ))) WARN( "glGetNamedProgramLocalParameterIuivEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedProgramLocalParameterdvEXT( GLuint program, GLenum target, GLuint index, GLdouble *params )
{
    struct glGetNamedProgramLocalParameterdvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, params %p\n", program, target, index, params );
    if ((status = UNIX_CALL( glGetNamedProgramLocalParameterdvEXT, &args ))) WARN( "glGetNamedProgramLocalParameterdvEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedProgramLocalParameterfvEXT( GLuint program, GLenum target, GLuint index, GLfloat *params )
{
    struct glGetNamedProgramLocalParameterfvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, params %p\n", program, target, index, params );
    if ((status = UNIX_CALL( glGetNamedProgramLocalParameterfvEXT, &args ))) WARN( "glGetNamedProgramLocalParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedProgramStringEXT( GLuint program, GLenum target, GLenum pname, void *string )
{
    struct glGetNamedProgramStringEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .pname = pname, .string = string };
    NTSTATUS status;
    TRACE( "program %d, target %d, pname %d, string %p\n", program, target, pname, string );
    if ((status = UNIX_CALL( glGetNamedProgramStringEXT, &args ))) WARN( "glGetNamedProgramStringEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedProgramivEXT( GLuint program, GLenum target, GLenum pname, GLint *params )
{
    struct glGetNamedProgramivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, pname %d, params %p\n", program, target, pname, params );
    if ((status = UNIX_CALL( glGetNamedProgramivEXT, &args ))) WARN( "glGetNamedProgramivEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedRenderbufferParameteriv( GLuint renderbuffer, GLenum pname, GLint *params )
{
    struct glGetNamedRenderbufferParameteriv_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "renderbuffer %d, pname %d, params %p\n", renderbuffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedRenderbufferParameteriv, &args ))) WARN( "glGetNamedRenderbufferParameteriv returned %#lx\n", status );
}

static void WINAPI glGetNamedRenderbufferParameterivEXT( GLuint renderbuffer, GLenum pname, GLint *params )
{
    struct glGetNamedRenderbufferParameterivEXT_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "renderbuffer %d, pname %d, params %p\n", renderbuffer, pname, params );
    if ((status = UNIX_CALL( glGetNamedRenderbufferParameterivEXT, &args ))) WARN( "glGetNamedRenderbufferParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetNamedStringARB( GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string )
{
    struct glGetNamedStringARB_params args = { .teb = NtCurrentTeb(), .namelen = namelen, .name = name, .bufSize = bufSize, .stringlen = stringlen, .string = string };
    NTSTATUS status;
    TRACE( "namelen %d, name %p, bufSize %d, stringlen %p, string %p\n", namelen, name, bufSize, stringlen, string );
    if ((status = UNIX_CALL( glGetNamedStringARB, &args ))) WARN( "glGetNamedStringARB returned %#lx\n", status );
}

static void WINAPI glGetNamedStringivARB( GLint namelen, const GLchar *name, GLenum pname, GLint *params )
{
    struct glGetNamedStringivARB_params args = { .teb = NtCurrentTeb(), .namelen = namelen, .name = name, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "namelen %d, name %p, pname %d, params %p\n", namelen, name, pname, params );
    if ((status = UNIX_CALL( glGetNamedStringivARB, &args ))) WARN( "glGetNamedStringivARB returned %#lx\n", status );
}

static void WINAPI glGetNextPerfQueryIdINTEL( GLuint queryId, GLuint *nextQueryId )
{
    struct glGetNextPerfQueryIdINTEL_params args = { .teb = NtCurrentTeb(), .queryId = queryId, .nextQueryId = nextQueryId };
    NTSTATUS status;
    TRACE( "queryId %d, nextQueryId %p\n", queryId, nextQueryId );
    if ((status = UNIX_CALL( glGetNextPerfQueryIdINTEL, &args ))) WARN( "glGetNextPerfQueryIdINTEL returned %#lx\n", status );
}

static void WINAPI glGetObjectBufferfvATI( GLuint buffer, GLenum pname, GLfloat *params )
{
    struct glGetObjectBufferfvATI_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "buffer %d, pname %d, params %p\n", buffer, pname, params );
    if ((status = UNIX_CALL( glGetObjectBufferfvATI, &args ))) WARN( "glGetObjectBufferfvATI returned %#lx\n", status );
}

static void WINAPI glGetObjectBufferivATI( GLuint buffer, GLenum pname, GLint *params )
{
    struct glGetObjectBufferivATI_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "buffer %d, pname %d, params %p\n", buffer, pname, params );
    if ((status = UNIX_CALL( glGetObjectBufferivATI, &args ))) WARN( "glGetObjectBufferivATI returned %#lx\n", status );
}

static void WINAPI glGetObjectLabel( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label )
{
    struct glGetObjectLabel_params args = { .teb = NtCurrentTeb(), .identifier = identifier, .name = name, .bufSize = bufSize, .length = length, .label = label };
    NTSTATUS status;
    TRACE( "identifier %d, name %d, bufSize %d, length %p, label %p\n", identifier, name, bufSize, length, label );
    if ((status = UNIX_CALL( glGetObjectLabel, &args ))) WARN( "glGetObjectLabel returned %#lx\n", status );
}

static void WINAPI glGetObjectLabelEXT( GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label )
{
    struct glGetObjectLabelEXT_params args = { .teb = NtCurrentTeb(), .type = type, .object = object, .bufSize = bufSize, .length = length, .label = label };
    NTSTATUS status;
    TRACE( "type %d, object %d, bufSize %d, length %p, label %p\n", type, object, bufSize, length, label );
    if ((status = UNIX_CALL( glGetObjectLabelEXT, &args ))) WARN( "glGetObjectLabelEXT returned %#lx\n", status );
}

static void WINAPI glGetObjectParameterfvARB( GLhandleARB obj, GLenum pname, GLfloat *params )
{
    struct glGetObjectParameterfvARB_params args = { .teb = NtCurrentTeb(), .obj = obj, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "obj %d, pname %d, params %p\n", obj, pname, params );
    if ((status = UNIX_CALL( glGetObjectParameterfvARB, &args ))) WARN( "glGetObjectParameterfvARB returned %#lx\n", status );
}

static void WINAPI glGetObjectParameterivAPPLE( GLenum objectType, GLuint name, GLenum pname, GLint *params )
{
    struct glGetObjectParameterivAPPLE_params args = { .teb = NtCurrentTeb(), .objectType = objectType, .name = name, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "objectType %d, name %d, pname %d, params %p\n", objectType, name, pname, params );
    if ((status = UNIX_CALL( glGetObjectParameterivAPPLE, &args ))) WARN( "glGetObjectParameterivAPPLE returned %#lx\n", status );
}

static void WINAPI glGetObjectParameterivARB( GLhandleARB obj, GLenum pname, GLint *params )
{
    struct glGetObjectParameterivARB_params args = { .teb = NtCurrentTeb(), .obj = obj, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "obj %d, pname %d, params %p\n", obj, pname, params );
    if ((status = UNIX_CALL( glGetObjectParameterivARB, &args ))) WARN( "glGetObjectParameterivARB returned %#lx\n", status );
}

static void WINAPI glGetObjectPtrLabel( const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label )
{
    struct glGetObjectPtrLabel_params args = { .teb = NtCurrentTeb(), .ptr = ptr, .bufSize = bufSize, .length = length, .label = label };
    NTSTATUS status;
    TRACE( "ptr %p, bufSize %d, length %p, label %p\n", ptr, bufSize, length, label );
    if ((status = UNIX_CALL( glGetObjectPtrLabel, &args ))) WARN( "glGetObjectPtrLabel returned %#lx\n", status );
}

static void WINAPI glGetOcclusionQueryivNV( GLuint id, GLenum pname, GLint *params )
{
    struct glGetOcclusionQueryivNV_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetOcclusionQueryivNV, &args ))) WARN( "glGetOcclusionQueryivNV returned %#lx\n", status );
}

static void WINAPI glGetOcclusionQueryuivNV( GLuint id, GLenum pname, GLuint *params )
{
    struct glGetOcclusionQueryuivNV_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetOcclusionQueryuivNV, &args ))) WARN( "glGetOcclusionQueryuivNV returned %#lx\n", status );
}

static void WINAPI glGetPathColorGenfvNV( GLenum color, GLenum pname, GLfloat *value )
{
    struct glGetPathColorGenfvNV_params args = { .teb = NtCurrentTeb(), .color = color, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "color %d, pname %d, value %p\n", color, pname, value );
    if ((status = UNIX_CALL( glGetPathColorGenfvNV, &args ))) WARN( "glGetPathColorGenfvNV returned %#lx\n", status );
}

static void WINAPI glGetPathColorGenivNV( GLenum color, GLenum pname, GLint *value )
{
    struct glGetPathColorGenivNV_params args = { .teb = NtCurrentTeb(), .color = color, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "color %d, pname %d, value %p\n", color, pname, value );
    if ((status = UNIX_CALL( glGetPathColorGenivNV, &args ))) WARN( "glGetPathColorGenivNV returned %#lx\n", status );
}

static void WINAPI glGetPathCommandsNV( GLuint path, GLubyte *commands )
{
    struct glGetPathCommandsNV_params args = { .teb = NtCurrentTeb(), .path = path, .commands = commands };
    NTSTATUS status;
    TRACE( "path %d, commands %p\n", path, commands );
    if ((status = UNIX_CALL( glGetPathCommandsNV, &args ))) WARN( "glGetPathCommandsNV returned %#lx\n", status );
}

static void WINAPI glGetPathCoordsNV( GLuint path, GLfloat *coords )
{
    struct glGetPathCoordsNV_params args = { .teb = NtCurrentTeb(), .path = path, .coords = coords };
    NTSTATUS status;
    TRACE( "path %d, coords %p\n", path, coords );
    if ((status = UNIX_CALL( glGetPathCoordsNV, &args ))) WARN( "glGetPathCoordsNV returned %#lx\n", status );
}

static void WINAPI glGetPathDashArrayNV( GLuint path, GLfloat *dashArray )
{
    struct glGetPathDashArrayNV_params args = { .teb = NtCurrentTeb(), .path = path, .dashArray = dashArray };
    NTSTATUS status;
    TRACE( "path %d, dashArray %p\n", path, dashArray );
    if ((status = UNIX_CALL( glGetPathDashArrayNV, &args ))) WARN( "glGetPathDashArrayNV returned %#lx\n", status );
}

static GLfloat WINAPI glGetPathLengthNV( GLuint path, GLsizei startSegment, GLsizei numSegments )
{
    struct glGetPathLengthNV_params args = { .teb = NtCurrentTeb(), .path = path, .startSegment = startSegment, .numSegments = numSegments };
    NTSTATUS status;
    TRACE( "path %d, startSegment %d, numSegments %d\n", path, startSegment, numSegments );
    if ((status = UNIX_CALL( glGetPathLengthNV, &args ))) WARN( "glGetPathLengthNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetPathMetricRangeNV( GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat *metrics )
{
    struct glGetPathMetricRangeNV_params args = { .teb = NtCurrentTeb(), .metricQueryMask = metricQueryMask, .firstPathName = firstPathName, .numPaths = numPaths, .stride = stride, .metrics = metrics };
    NTSTATUS status;
    TRACE( "metricQueryMask %d, firstPathName %d, numPaths %d, stride %d, metrics %p\n", metricQueryMask, firstPathName, numPaths, stride, metrics );
    if ((status = UNIX_CALL( glGetPathMetricRangeNV, &args ))) WARN( "glGetPathMetricRangeNV returned %#lx\n", status );
}

static void WINAPI glGetPathMetricsNV( GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLsizei stride, GLfloat *metrics )
{
    struct glGetPathMetricsNV_params args = { .teb = NtCurrentTeb(), .metricQueryMask = metricQueryMask, .numPaths = numPaths, .pathNameType = pathNameType, .paths = paths, .pathBase = pathBase, .stride = stride, .metrics = metrics };
    NTSTATUS status;
    TRACE( "metricQueryMask %d, numPaths %d, pathNameType %d, paths %p, pathBase %d, stride %d, metrics %p\n", metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics );
    if ((status = UNIX_CALL( glGetPathMetricsNV, &args ))) WARN( "glGetPathMetricsNV returned %#lx\n", status );
}

static void WINAPI glGetPathParameterfvNV( GLuint path, GLenum pname, GLfloat *value )
{
    struct glGetPathParameterfvNV_params args = { .teb = NtCurrentTeb(), .path = path, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "path %d, pname %d, value %p\n", path, pname, value );
    if ((status = UNIX_CALL( glGetPathParameterfvNV, &args ))) WARN( "glGetPathParameterfvNV returned %#lx\n", status );
}

static void WINAPI glGetPathParameterivNV( GLuint path, GLenum pname, GLint *value )
{
    struct glGetPathParameterivNV_params args = { .teb = NtCurrentTeb(), .path = path, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "path %d, pname %d, value %p\n", path, pname, value );
    if ((status = UNIX_CALL( glGetPathParameterivNV, &args ))) WARN( "glGetPathParameterivNV returned %#lx\n", status );
}

static void WINAPI glGetPathSpacingNV( GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing )
{
    struct glGetPathSpacingNV_params args = { .teb = NtCurrentTeb(), .pathListMode = pathListMode, .numPaths = numPaths, .pathNameType = pathNameType, .paths = paths, .pathBase = pathBase, .advanceScale = advanceScale, .kerningScale = kerningScale, .transformType = transformType, .returnedSpacing = returnedSpacing };
    NTSTATUS status;
    TRACE( "pathListMode %d, numPaths %d, pathNameType %d, paths %p, pathBase %d, advanceScale %f, kerningScale %f, transformType %d, returnedSpacing %p\n", pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing );
    if ((status = UNIX_CALL( glGetPathSpacingNV, &args ))) WARN( "glGetPathSpacingNV returned %#lx\n", status );
}

static void WINAPI glGetPathTexGenfvNV( GLenum texCoordSet, GLenum pname, GLfloat *value )
{
    struct glGetPathTexGenfvNV_params args = { .teb = NtCurrentTeb(), .texCoordSet = texCoordSet, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "texCoordSet %d, pname %d, value %p\n", texCoordSet, pname, value );
    if ((status = UNIX_CALL( glGetPathTexGenfvNV, &args ))) WARN( "glGetPathTexGenfvNV returned %#lx\n", status );
}

static void WINAPI glGetPathTexGenivNV( GLenum texCoordSet, GLenum pname, GLint *value )
{
    struct glGetPathTexGenivNV_params args = { .teb = NtCurrentTeb(), .texCoordSet = texCoordSet, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "texCoordSet %d, pname %d, value %p\n", texCoordSet, pname, value );
    if ((status = UNIX_CALL( glGetPathTexGenivNV, &args ))) WARN( "glGetPathTexGenivNV returned %#lx\n", status );
}

static void WINAPI glGetPerfCounterInfoINTEL( GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar *counterName, GLuint counterDescLength, GLchar *counterDesc, GLuint *counterOffset, GLuint *counterDataSize, GLuint *counterTypeEnum, GLuint *counterDataTypeEnum, GLuint64 *rawCounterMaxValue )
{
    struct glGetPerfCounterInfoINTEL_params args = { .teb = NtCurrentTeb(), .queryId = queryId, .counterId = counterId, .counterNameLength = counterNameLength, .counterName = counterName, .counterDescLength = counterDescLength, .counterDesc = counterDesc, .counterOffset = counterOffset, .counterDataSize = counterDataSize, .counterTypeEnum = counterTypeEnum, .counterDataTypeEnum = counterDataTypeEnum, .rawCounterMaxValue = rawCounterMaxValue };
    NTSTATUS status;
    TRACE( "queryId %d, counterId %d, counterNameLength %d, counterName %p, counterDescLength %d, counterDesc %p, counterOffset %p, counterDataSize %p, counterTypeEnum %p, counterDataTypeEnum %p, rawCounterMaxValue %p\n", queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue );
    if ((status = UNIX_CALL( glGetPerfCounterInfoINTEL, &args ))) WARN( "glGetPerfCounterInfoINTEL returned %#lx\n", status );
}

static void WINAPI glGetPerfMonitorCounterDataAMD( GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten )
{
    struct glGetPerfMonitorCounterDataAMD_params args = { .teb = NtCurrentTeb(), .monitor = monitor, .pname = pname, .dataSize = dataSize, .data = data, .bytesWritten = bytesWritten };
    NTSTATUS status;
    TRACE( "monitor %d, pname %d, dataSize %d, data %p, bytesWritten %p\n", monitor, pname, dataSize, data, bytesWritten );
    if ((status = UNIX_CALL( glGetPerfMonitorCounterDataAMD, &args ))) WARN( "glGetPerfMonitorCounterDataAMD returned %#lx\n", status );
}

static void WINAPI glGetPerfMonitorCounterInfoAMD( GLuint group, GLuint counter, GLenum pname, void *data )
{
    struct glGetPerfMonitorCounterInfoAMD_params args = { .teb = NtCurrentTeb(), .group = group, .counter = counter, .pname = pname, .data = data };
    NTSTATUS status;
    TRACE( "group %d, counter %d, pname %d, data %p\n", group, counter, pname, data );
    if ((status = UNIX_CALL( glGetPerfMonitorCounterInfoAMD, &args ))) WARN( "glGetPerfMonitorCounterInfoAMD returned %#lx\n", status );
}

static void WINAPI glGetPerfMonitorCounterStringAMD( GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString )
{
    struct glGetPerfMonitorCounterStringAMD_params args = { .teb = NtCurrentTeb(), .group = group, .counter = counter, .bufSize = bufSize, .length = length, .counterString = counterString };
    NTSTATUS status;
    TRACE( "group %d, counter %d, bufSize %d, length %p, counterString %p\n", group, counter, bufSize, length, counterString );
    if ((status = UNIX_CALL( glGetPerfMonitorCounterStringAMD, &args ))) WARN( "glGetPerfMonitorCounterStringAMD returned %#lx\n", status );
}

static void WINAPI glGetPerfMonitorCountersAMD( GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters )
{
    struct glGetPerfMonitorCountersAMD_params args = { .teb = NtCurrentTeb(), .group = group, .numCounters = numCounters, .maxActiveCounters = maxActiveCounters, .counterSize = counterSize, .counters = counters };
    NTSTATUS status;
    TRACE( "group %d, numCounters %p, maxActiveCounters %p, counterSize %d, counters %p\n", group, numCounters, maxActiveCounters, counterSize, counters );
    if ((status = UNIX_CALL( glGetPerfMonitorCountersAMD, &args ))) WARN( "glGetPerfMonitorCountersAMD returned %#lx\n", status );
}

static void WINAPI glGetPerfMonitorGroupStringAMD( GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString )
{
    struct glGetPerfMonitorGroupStringAMD_params args = { .teb = NtCurrentTeb(), .group = group, .bufSize = bufSize, .length = length, .groupString = groupString };
    NTSTATUS status;
    TRACE( "group %d, bufSize %d, length %p, groupString %p\n", group, bufSize, length, groupString );
    if ((status = UNIX_CALL( glGetPerfMonitorGroupStringAMD, &args ))) WARN( "glGetPerfMonitorGroupStringAMD returned %#lx\n", status );
}

static void WINAPI glGetPerfMonitorGroupsAMD( GLint *numGroups, GLsizei groupsSize, GLuint *groups )
{
    struct glGetPerfMonitorGroupsAMD_params args = { .teb = NtCurrentTeb(), .numGroups = numGroups, .groupsSize = groupsSize, .groups = groups };
    NTSTATUS status;
    TRACE( "numGroups %p, groupsSize %d, groups %p\n", numGroups, groupsSize, groups );
    if ((status = UNIX_CALL( glGetPerfMonitorGroupsAMD, &args ))) WARN( "glGetPerfMonitorGroupsAMD returned %#lx\n", status );
}

static void WINAPI glGetPerfQueryDataINTEL( GLuint queryHandle, GLuint flags, GLsizei dataSize, void *data, GLuint *bytesWritten )
{
    struct glGetPerfQueryDataINTEL_params args = { .teb = NtCurrentTeb(), .queryHandle = queryHandle, .flags = flags, .dataSize = dataSize, .data = data, .bytesWritten = bytesWritten };
    NTSTATUS status;
    TRACE( "queryHandle %d, flags %d, dataSize %d, data %p, bytesWritten %p\n", queryHandle, flags, dataSize, data, bytesWritten );
    if ((status = UNIX_CALL( glGetPerfQueryDataINTEL, &args ))) WARN( "glGetPerfQueryDataINTEL returned %#lx\n", status );
}

static void WINAPI glGetPerfQueryIdByNameINTEL( GLchar *queryName, GLuint *queryId )
{
    struct glGetPerfQueryIdByNameINTEL_params args = { .teb = NtCurrentTeb(), .queryName = queryName, .queryId = queryId };
    NTSTATUS status;
    TRACE( "queryName %p, queryId %p\n", queryName, queryId );
    if ((status = UNIX_CALL( glGetPerfQueryIdByNameINTEL, &args ))) WARN( "glGetPerfQueryIdByNameINTEL returned %#lx\n", status );
}

static void WINAPI glGetPerfQueryInfoINTEL( GLuint queryId, GLuint queryNameLength, GLchar *queryName, GLuint *dataSize, GLuint *noCounters, GLuint *noInstances, GLuint *capsMask )
{
    struct glGetPerfQueryInfoINTEL_params args = { .teb = NtCurrentTeb(), .queryId = queryId, .queryNameLength = queryNameLength, .queryName = queryName, .dataSize = dataSize, .noCounters = noCounters, .noInstances = noInstances, .capsMask = capsMask };
    NTSTATUS status;
    TRACE( "queryId %d, queryNameLength %d, queryName %p, dataSize %p, noCounters %p, noInstances %p, capsMask %p\n", queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask );
    if ((status = UNIX_CALL( glGetPerfQueryInfoINTEL, &args ))) WARN( "glGetPerfQueryInfoINTEL returned %#lx\n", status );
}

static void WINAPI glGetPixelMapxv( GLenum map, GLint size, GLfixed *values )
{
    struct glGetPixelMapxv_params args = { .teb = NtCurrentTeb(), .map = map, .size = size, .values = values };
    NTSTATUS status;
    TRACE( "map %d, size %d, values %p\n", map, size, values );
    if ((status = UNIX_CALL( glGetPixelMapxv, &args ))) WARN( "glGetPixelMapxv returned %#lx\n", status );
}

static void WINAPI glGetPixelTexGenParameterfvSGIS( GLenum pname, GLfloat *params )
{
    struct glGetPixelTexGenParameterfvSGIS_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glGetPixelTexGenParameterfvSGIS, &args ))) WARN( "glGetPixelTexGenParameterfvSGIS returned %#lx\n", status );
}

static void WINAPI glGetPixelTexGenParameterivSGIS( GLenum pname, GLint *params )
{
    struct glGetPixelTexGenParameterivSGIS_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glGetPixelTexGenParameterivSGIS, &args ))) WARN( "glGetPixelTexGenParameterivSGIS returned %#lx\n", status );
}

static void WINAPI glGetPixelTransformParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetPixelTransformParameterfvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetPixelTransformParameterfvEXT, &args ))) WARN( "glGetPixelTransformParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetPixelTransformParameterivEXT( GLenum target, GLenum pname, GLint *params )
{
    struct glGetPixelTransformParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetPixelTransformParameterivEXT, &args ))) WARN( "glGetPixelTransformParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetPointerIndexedvEXT( GLenum target, GLuint index, void **data )
{
    struct glGetPointerIndexedvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetPointerIndexedvEXT, &args ))) WARN( "glGetPointerIndexedvEXT returned %#lx\n", status );
}

static void WINAPI glGetPointeri_vEXT( GLenum pname, GLuint index, void **params )
{
    struct glGetPointeri_vEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, index %d, params %p\n", pname, index, params );
    if ((status = UNIX_CALL( glGetPointeri_vEXT, &args ))) WARN( "glGetPointeri_vEXT returned %#lx\n", status );
}

static void WINAPI glGetPointervEXT( GLenum pname, void **params )
{
    struct glGetPointervEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glGetPointervEXT, &args ))) WARN( "glGetPointervEXT returned %#lx\n", status );
}

static void WINAPI glGetProgramBinary( GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary )
{
    struct glGetProgramBinary_params args = { .teb = NtCurrentTeb(), .program = program, .bufSize = bufSize, .length = length, .binaryFormat = binaryFormat, .binary = binary };
    NTSTATUS status;
    TRACE( "program %d, bufSize %d, length %p, binaryFormat %p, binary %p\n", program, bufSize, length, binaryFormat, binary );
    if ((status = UNIX_CALL( glGetProgramBinary, &args ))) WARN( "glGetProgramBinary returned %#lx\n", status );
}

static void WINAPI glGetProgramEnvParameterIivNV( GLenum target, GLuint index, GLint *params )
{
    struct glGetProgramEnvParameterIivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glGetProgramEnvParameterIivNV, &args ))) WARN( "glGetProgramEnvParameterIivNV returned %#lx\n", status );
}

static void WINAPI glGetProgramEnvParameterIuivNV( GLenum target, GLuint index, GLuint *params )
{
    struct glGetProgramEnvParameterIuivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glGetProgramEnvParameterIuivNV, &args ))) WARN( "glGetProgramEnvParameterIuivNV returned %#lx\n", status );
}

static void WINAPI glGetProgramEnvParameterdvARB( GLenum target, GLuint index, GLdouble *params )
{
    struct glGetProgramEnvParameterdvARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glGetProgramEnvParameterdvARB, &args ))) WARN( "glGetProgramEnvParameterdvARB returned %#lx\n", status );
}

static void WINAPI glGetProgramEnvParameterfvARB( GLenum target, GLuint index, GLfloat *params )
{
    struct glGetProgramEnvParameterfvARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glGetProgramEnvParameterfvARB, &args ))) WARN( "glGetProgramEnvParameterfvARB returned %#lx\n", status );
}

static void WINAPI glGetProgramInfoLog( GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog )
{
    struct glGetProgramInfoLog_params args = { .teb = NtCurrentTeb(), .program = program, .bufSize = bufSize, .length = length, .infoLog = infoLog };
    NTSTATUS status;
    TRACE( "program %d, bufSize %d, length %p, infoLog %p\n", program, bufSize, length, infoLog );
    if ((status = UNIX_CALL( glGetProgramInfoLog, &args ))) WARN( "glGetProgramInfoLog returned %#lx\n", status );
}

static void WINAPI glGetProgramInterfaceiv( GLuint program, GLenum programInterface, GLenum pname, GLint *params )
{
    struct glGetProgramInterfaceiv_params args = { .teb = NtCurrentTeb(), .program = program, .programInterface = programInterface, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "program %d, programInterface %d, pname %d, params %p\n", program, programInterface, pname, params );
    if ((status = UNIX_CALL( glGetProgramInterfaceiv, &args ))) WARN( "glGetProgramInterfaceiv returned %#lx\n", status );
}

static void WINAPI glGetProgramLocalParameterIivNV( GLenum target, GLuint index, GLint *params )
{
    struct glGetProgramLocalParameterIivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glGetProgramLocalParameterIivNV, &args ))) WARN( "glGetProgramLocalParameterIivNV returned %#lx\n", status );
}

static void WINAPI glGetProgramLocalParameterIuivNV( GLenum target, GLuint index, GLuint *params )
{
    struct glGetProgramLocalParameterIuivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glGetProgramLocalParameterIuivNV, &args ))) WARN( "glGetProgramLocalParameterIuivNV returned %#lx\n", status );
}

static void WINAPI glGetProgramLocalParameterdvARB( GLenum target, GLuint index, GLdouble *params )
{
    struct glGetProgramLocalParameterdvARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glGetProgramLocalParameterdvARB, &args ))) WARN( "glGetProgramLocalParameterdvARB returned %#lx\n", status );
}

static void WINAPI glGetProgramLocalParameterfvARB( GLenum target, GLuint index, GLfloat *params )
{
    struct glGetProgramLocalParameterfvARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glGetProgramLocalParameterfvARB, &args ))) WARN( "glGetProgramLocalParameterfvARB returned %#lx\n", status );
}

static void WINAPI glGetProgramNamedParameterdvNV( GLuint id, GLsizei len, const GLubyte *name, GLdouble *params )
{
    struct glGetProgramNamedParameterdvNV_params args = { .teb = NtCurrentTeb(), .id = id, .len = len, .name = name, .params = params };
    NTSTATUS status;
    TRACE( "id %d, len %d, name %p, params %p\n", id, len, name, params );
    if ((status = UNIX_CALL( glGetProgramNamedParameterdvNV, &args ))) WARN( "glGetProgramNamedParameterdvNV returned %#lx\n", status );
}

static void WINAPI glGetProgramNamedParameterfvNV( GLuint id, GLsizei len, const GLubyte *name, GLfloat *params )
{
    struct glGetProgramNamedParameterfvNV_params args = { .teb = NtCurrentTeb(), .id = id, .len = len, .name = name, .params = params };
    NTSTATUS status;
    TRACE( "id %d, len %d, name %p, params %p\n", id, len, name, params );
    if ((status = UNIX_CALL( glGetProgramNamedParameterfvNV, &args ))) WARN( "glGetProgramNamedParameterfvNV returned %#lx\n", status );
}

static void WINAPI glGetProgramParameterdvNV( GLenum target, GLuint index, GLenum pname, GLdouble *params )
{
    struct glGetProgramParameterdvNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, pname %d, params %p\n", target, index, pname, params );
    if ((status = UNIX_CALL( glGetProgramParameterdvNV, &args ))) WARN( "glGetProgramParameterdvNV returned %#lx\n", status );
}

static void WINAPI glGetProgramParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat *params )
{
    struct glGetProgramParameterfvNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, pname %d, params %p\n", target, index, pname, params );
    if ((status = UNIX_CALL( glGetProgramParameterfvNV, &args ))) WARN( "glGetProgramParameterfvNV returned %#lx\n", status );
}

static void WINAPI glGetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog )
{
    struct glGetProgramPipelineInfoLog_params args = { .teb = NtCurrentTeb(), .pipeline = pipeline, .bufSize = bufSize, .length = length, .infoLog = infoLog };
    NTSTATUS status;
    TRACE( "pipeline %d, bufSize %d, length %p, infoLog %p\n", pipeline, bufSize, length, infoLog );
    if ((status = UNIX_CALL( glGetProgramPipelineInfoLog, &args ))) WARN( "glGetProgramPipelineInfoLog returned %#lx\n", status );
}

static void WINAPI glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint *params )
{
    struct glGetProgramPipelineiv_params args = { .teb = NtCurrentTeb(), .pipeline = pipeline, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pipeline %d, pname %d, params %p\n", pipeline, pname, params );
    if ((status = UNIX_CALL( glGetProgramPipelineiv, &args ))) WARN( "glGetProgramPipelineiv returned %#lx\n", status );
}

static GLuint WINAPI glGetProgramResourceIndex( GLuint program, GLenum programInterface, const GLchar *name )
{
    struct glGetProgramResourceIndex_params args = { .teb = NtCurrentTeb(), .program = program, .programInterface = programInterface, .name = name };
    NTSTATUS status;
    TRACE( "program %d, programInterface %d, name %p\n", program, programInterface, name );
    if ((status = UNIX_CALL( glGetProgramResourceIndex, &args ))) WARN( "glGetProgramResourceIndex returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glGetProgramResourceLocation( GLuint program, GLenum programInterface, const GLchar *name )
{
    struct glGetProgramResourceLocation_params args = { .teb = NtCurrentTeb(), .program = program, .programInterface = programInterface, .name = name };
    NTSTATUS status;
    TRACE( "program %d, programInterface %d, name %p\n", program, programInterface, name );
    if ((status = UNIX_CALL( glGetProgramResourceLocation, &args ))) WARN( "glGetProgramResourceLocation returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glGetProgramResourceLocationIndex( GLuint program, GLenum programInterface, const GLchar *name )
{
    struct glGetProgramResourceLocationIndex_params args = { .teb = NtCurrentTeb(), .program = program, .programInterface = programInterface, .name = name };
    NTSTATUS status;
    TRACE( "program %d, programInterface %d, name %p\n", program, programInterface, name );
    if ((status = UNIX_CALL( glGetProgramResourceLocationIndex, &args ))) WARN( "glGetProgramResourceLocationIndex returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetProgramResourceName( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name )
{
    struct glGetProgramResourceName_params args = { .teb = NtCurrentTeb(), .program = program, .programInterface = programInterface, .index = index, .bufSize = bufSize, .length = length, .name = name };
    NTSTATUS status;
    TRACE( "program %d, programInterface %d, index %d, bufSize %d, length %p, name %p\n", program, programInterface, index, bufSize, length, name );
    if ((status = UNIX_CALL( glGetProgramResourceName, &args ))) WARN( "glGetProgramResourceName returned %#lx\n", status );
}

static void WINAPI glGetProgramResourcefvNV( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei count, GLsizei *length, GLfloat *params )
{
    struct glGetProgramResourcefvNV_params args = { .teb = NtCurrentTeb(), .program = program, .programInterface = programInterface, .index = index, .propCount = propCount, .props = props, .count = count, .length = length, .params = params };
    NTSTATUS status;
    TRACE( "program %d, programInterface %d, index %d, propCount %d, props %p, count %d, length %p, params %p\n", program, programInterface, index, propCount, props, count, length, params );
    if ((status = UNIX_CALL( glGetProgramResourcefvNV, &args ))) WARN( "glGetProgramResourcefvNV returned %#lx\n", status );
}

static void WINAPI glGetProgramResourceiv( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei count, GLsizei *length, GLint *params )
{
    struct glGetProgramResourceiv_params args = { .teb = NtCurrentTeb(), .program = program, .programInterface = programInterface, .index = index, .propCount = propCount, .props = props, .count = count, .length = length, .params = params };
    NTSTATUS status;
    TRACE( "program %d, programInterface %d, index %d, propCount %d, props %p, count %d, length %p, params %p\n", program, programInterface, index, propCount, props, count, length, params );
    if ((status = UNIX_CALL( glGetProgramResourceiv, &args ))) WARN( "glGetProgramResourceiv returned %#lx\n", status );
}

static void WINAPI glGetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint *values )
{
    struct glGetProgramStageiv_params args = { .teb = NtCurrentTeb(), .program = program, .shadertype = shadertype, .pname = pname, .values = values };
    NTSTATUS status;
    TRACE( "program %d, shadertype %d, pname %d, values %p\n", program, shadertype, pname, values );
    if ((status = UNIX_CALL( glGetProgramStageiv, &args ))) WARN( "glGetProgramStageiv returned %#lx\n", status );
}

static void WINAPI glGetProgramStringARB( GLenum target, GLenum pname, void *string )
{
    struct glGetProgramStringARB_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .string = string };
    NTSTATUS status;
    TRACE( "target %d, pname %d, string %p\n", target, pname, string );
    if ((status = UNIX_CALL( glGetProgramStringARB, &args ))) WARN( "glGetProgramStringARB returned %#lx\n", status );
}

static void WINAPI glGetProgramStringNV( GLuint id, GLenum pname, GLubyte *program )
{
    struct glGetProgramStringNV_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .program = program };
    NTSTATUS status;
    TRACE( "id %d, pname %d, program %p\n", id, pname, program );
    if ((status = UNIX_CALL( glGetProgramStringNV, &args ))) WARN( "glGetProgramStringNV returned %#lx\n", status );
}

static void WINAPI glGetProgramSubroutineParameteruivNV( GLenum target, GLuint index, GLuint *param )
{
    struct glGetProgramSubroutineParameteruivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .param = param };
    NTSTATUS status;
    TRACE( "target %d, index %d, param %p\n", target, index, param );
    if ((status = UNIX_CALL( glGetProgramSubroutineParameteruivNV, &args ))) WARN( "glGetProgramSubroutineParameteruivNV returned %#lx\n", status );
}

static void WINAPI glGetProgramiv( GLuint program, GLenum pname, GLint *params )
{
    struct glGetProgramiv_params args = { .teb = NtCurrentTeb(), .program = program, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "program %d, pname %d, params %p\n", program, pname, params );
    if ((status = UNIX_CALL( glGetProgramiv, &args ))) WARN( "glGetProgramiv returned %#lx\n", status );
}

static void WINAPI glGetProgramivARB( GLenum target, GLenum pname, GLint *params )
{
    struct glGetProgramivARB_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetProgramivARB, &args ))) WARN( "glGetProgramivARB returned %#lx\n", status );
}

static void WINAPI glGetProgramivNV( GLuint id, GLenum pname, GLint *params )
{
    struct glGetProgramivNV_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetProgramivNV, &args ))) WARN( "glGetProgramivNV returned %#lx\n", status );
}

static void WINAPI glGetQueryBufferObjecti64v( GLuint id, GLuint buffer, GLenum pname, GLintptr offset )
{
    struct glGetQueryBufferObjecti64v_params args = { .teb = NtCurrentTeb(), .id = id, .buffer = buffer, .pname = pname, .offset = offset };
    NTSTATUS status;
    TRACE( "id %d, buffer %d, pname %d, offset %Id\n", id, buffer, pname, offset );
    if ((status = UNIX_CALL( glGetQueryBufferObjecti64v, &args ))) WARN( "glGetQueryBufferObjecti64v returned %#lx\n", status );
}

static void WINAPI glGetQueryBufferObjectiv( GLuint id, GLuint buffer, GLenum pname, GLintptr offset )
{
    struct glGetQueryBufferObjectiv_params args = { .teb = NtCurrentTeb(), .id = id, .buffer = buffer, .pname = pname, .offset = offset };
    NTSTATUS status;
    TRACE( "id %d, buffer %d, pname %d, offset %Id\n", id, buffer, pname, offset );
    if ((status = UNIX_CALL( glGetQueryBufferObjectiv, &args ))) WARN( "glGetQueryBufferObjectiv returned %#lx\n", status );
}

static void WINAPI glGetQueryBufferObjectui64v( GLuint id, GLuint buffer, GLenum pname, GLintptr offset )
{
    struct glGetQueryBufferObjectui64v_params args = { .teb = NtCurrentTeb(), .id = id, .buffer = buffer, .pname = pname, .offset = offset };
    NTSTATUS status;
    TRACE( "id %d, buffer %d, pname %d, offset %Id\n", id, buffer, pname, offset );
    if ((status = UNIX_CALL( glGetQueryBufferObjectui64v, &args ))) WARN( "glGetQueryBufferObjectui64v returned %#lx\n", status );
}

static void WINAPI glGetQueryBufferObjectuiv( GLuint id, GLuint buffer, GLenum pname, GLintptr offset )
{
    struct glGetQueryBufferObjectuiv_params args = { .teb = NtCurrentTeb(), .id = id, .buffer = buffer, .pname = pname, .offset = offset };
    NTSTATUS status;
    TRACE( "id %d, buffer %d, pname %d, offset %Id\n", id, buffer, pname, offset );
    if ((status = UNIX_CALL( glGetQueryBufferObjectuiv, &args ))) WARN( "glGetQueryBufferObjectuiv returned %#lx\n", status );
}

static void WINAPI glGetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint *params )
{
    struct glGetQueryIndexediv_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, pname %d, params %p\n", target, index, pname, params );
    if ((status = UNIX_CALL( glGetQueryIndexediv, &args ))) WARN( "glGetQueryIndexediv returned %#lx\n", status );
}

static void WINAPI glGetQueryObjecti64v( GLuint id, GLenum pname, GLint64 *params )
{
    struct glGetQueryObjecti64v_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetQueryObjecti64v, &args ))) WARN( "glGetQueryObjecti64v returned %#lx\n", status );
}

static void WINAPI glGetQueryObjecti64vEXT( GLuint id, GLenum pname, GLint64 *params )
{
    struct glGetQueryObjecti64vEXT_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetQueryObjecti64vEXT, &args ))) WARN( "glGetQueryObjecti64vEXT returned %#lx\n", status );
}

static void WINAPI glGetQueryObjectiv( GLuint id, GLenum pname, GLint *params )
{
    struct glGetQueryObjectiv_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetQueryObjectiv, &args ))) WARN( "glGetQueryObjectiv returned %#lx\n", status );
}

static void WINAPI glGetQueryObjectivARB( GLuint id, GLenum pname, GLint *params )
{
    struct glGetQueryObjectivARB_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetQueryObjectivARB, &args ))) WARN( "glGetQueryObjectivARB returned %#lx\n", status );
}

static void WINAPI glGetQueryObjectui64v( GLuint id, GLenum pname, GLuint64 *params )
{
    struct glGetQueryObjectui64v_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetQueryObjectui64v, &args ))) WARN( "glGetQueryObjectui64v returned %#lx\n", status );
}

static void WINAPI glGetQueryObjectui64vEXT( GLuint id, GLenum pname, GLuint64 *params )
{
    struct glGetQueryObjectui64vEXT_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetQueryObjectui64vEXT, &args ))) WARN( "glGetQueryObjectui64vEXT returned %#lx\n", status );
}

static void WINAPI glGetQueryObjectuiv( GLuint id, GLenum pname, GLuint *params )
{
    struct glGetQueryObjectuiv_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetQueryObjectuiv, &args ))) WARN( "glGetQueryObjectuiv returned %#lx\n", status );
}

static void WINAPI glGetQueryObjectuivARB( GLuint id, GLenum pname, GLuint *params )
{
    struct glGetQueryObjectuivARB_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetQueryObjectuivARB, &args ))) WARN( "glGetQueryObjectuivARB returned %#lx\n", status );
}

static void WINAPI glGetQueryiv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetQueryiv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetQueryiv, &args ))) WARN( "glGetQueryiv returned %#lx\n", status );
}

static void WINAPI glGetQueryivARB( GLenum target, GLenum pname, GLint *params )
{
    struct glGetQueryivARB_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetQueryivARB, &args ))) WARN( "glGetQueryivARB returned %#lx\n", status );
}

static void WINAPI glGetRenderbufferParameteriv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetRenderbufferParameteriv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetRenderbufferParameteriv, &args ))) WARN( "glGetRenderbufferParameteriv returned %#lx\n", status );
}

static void WINAPI glGetRenderbufferParameterivEXT( GLenum target, GLenum pname, GLint *params )
{
    struct glGetRenderbufferParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetRenderbufferParameterivEXT, &args ))) WARN( "glGetRenderbufferParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint *params )
{
    struct glGetSamplerParameterIiv_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, params %p\n", sampler, pname, params );
    if ((status = UNIX_CALL( glGetSamplerParameterIiv, &args ))) WARN( "glGetSamplerParameterIiv returned %#lx\n", status );
}

static void WINAPI glGetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint *params )
{
    struct glGetSamplerParameterIuiv_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, params %p\n", sampler, pname, params );
    if ((status = UNIX_CALL( glGetSamplerParameterIuiv, &args ))) WARN( "glGetSamplerParameterIuiv returned %#lx\n", status );
}

static void WINAPI glGetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat *params )
{
    struct glGetSamplerParameterfv_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, params %p\n", sampler, pname, params );
    if ((status = UNIX_CALL( glGetSamplerParameterfv, &args ))) WARN( "glGetSamplerParameterfv returned %#lx\n", status );
}

static void WINAPI glGetSamplerParameteriv( GLuint sampler, GLenum pname, GLint *params )
{
    struct glGetSamplerParameteriv_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, params %p\n", sampler, pname, params );
    if ((status = UNIX_CALL( glGetSamplerParameteriv, &args ))) WARN( "glGetSamplerParameteriv returned %#lx\n", status );
}

static void WINAPI glGetSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, GLuint64 *params )
{
    struct glGetSemaphoreParameterui64vEXT_params args = { .teb = NtCurrentTeb(), .semaphore = semaphore, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "semaphore %d, pname %d, params %p\n", semaphore, pname, params );
    if ((status = UNIX_CALL( glGetSemaphoreParameterui64vEXT, &args ))) WARN( "glGetSemaphoreParameterui64vEXT returned %#lx\n", status );
}

static void WINAPI glGetSeparableFilter( GLenum target, GLenum format, GLenum type, void *row, void *column, void *span )
{
    struct glGetSeparableFilter_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .row = row, .column = column, .span = span };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, row %p, column %p, span %p\n", target, format, type, row, column, span );
    if ((status = UNIX_CALL( glGetSeparableFilter, &args ))) WARN( "glGetSeparableFilter returned %#lx\n", status );
}

static void WINAPI glGetSeparableFilterEXT( GLenum target, GLenum format, GLenum type, void *row, void *column, void *span )
{
    struct glGetSeparableFilterEXT_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .row = row, .column = column, .span = span };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, row %p, column %p, span %p\n", target, format, type, row, column, span );
    if ((status = UNIX_CALL( glGetSeparableFilterEXT, &args ))) WARN( "glGetSeparableFilterEXT returned %#lx\n", status );
}

static void WINAPI glGetShaderInfoLog( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog )
{
    struct glGetShaderInfoLog_params args = { .teb = NtCurrentTeb(), .shader = shader, .bufSize = bufSize, .length = length, .infoLog = infoLog };
    NTSTATUS status;
    TRACE( "shader %d, bufSize %d, length %p, infoLog %p\n", shader, bufSize, length, infoLog );
    if ((status = UNIX_CALL( glGetShaderInfoLog, &args ))) WARN( "glGetShaderInfoLog returned %#lx\n", status );
}

static void WINAPI glGetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision )
{
    struct glGetShaderPrecisionFormat_params args = { .teb = NtCurrentTeb(), .shadertype = shadertype, .precisiontype = precisiontype, .range = range, .precision = precision };
    NTSTATUS status;
    TRACE( "shadertype %d, precisiontype %d, range %p, precision %p\n", shadertype, precisiontype, range, precision );
    if ((status = UNIX_CALL( glGetShaderPrecisionFormat, &args ))) WARN( "glGetShaderPrecisionFormat returned %#lx\n", status );
}

static void WINAPI glGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source )
{
    struct glGetShaderSource_params args = { .teb = NtCurrentTeb(), .shader = shader, .bufSize = bufSize, .length = length, .source = source };
    NTSTATUS status;
    TRACE( "shader %d, bufSize %d, length %p, source %p\n", shader, bufSize, length, source );
    if ((status = UNIX_CALL( glGetShaderSource, &args ))) WARN( "glGetShaderSource returned %#lx\n", status );
}

static void WINAPI glGetShaderSourceARB( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source )
{
    struct glGetShaderSourceARB_params args = { .teb = NtCurrentTeb(), .obj = obj, .maxLength = maxLength, .length = length, .source = source };
    NTSTATUS status;
    TRACE( "obj %d, maxLength %d, length %p, source %p\n", obj, maxLength, length, source );
    if ((status = UNIX_CALL( glGetShaderSourceARB, &args ))) WARN( "glGetShaderSourceARB returned %#lx\n", status );
}

static void WINAPI glGetShaderiv( GLuint shader, GLenum pname, GLint *params )
{
    struct glGetShaderiv_params args = { .teb = NtCurrentTeb(), .shader = shader, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "shader %d, pname %d, params %p\n", shader, pname, params );
    if ((status = UNIX_CALL( glGetShaderiv, &args ))) WARN( "glGetShaderiv returned %#lx\n", status );
}

static void WINAPI glGetShadingRateImagePaletteNV( GLuint viewport, GLuint entry, GLenum *rate )
{
    struct glGetShadingRateImagePaletteNV_params args = { .teb = NtCurrentTeb(), .viewport = viewport, .entry = entry, .rate = rate };
    NTSTATUS status;
    TRACE( "viewport %d, entry %d, rate %p\n", viewport, entry, rate );
    if ((status = UNIX_CALL( glGetShadingRateImagePaletteNV, &args ))) WARN( "glGetShadingRateImagePaletteNV returned %#lx\n", status );
}

static void WINAPI glGetShadingRateSampleLocationivNV( GLenum rate, GLuint samples, GLuint index, GLint *location )
{
    struct glGetShadingRateSampleLocationivNV_params args = { .teb = NtCurrentTeb(), .rate = rate, .samples = samples, .index = index, .location = location };
    NTSTATUS status;
    TRACE( "rate %d, samples %d, index %d, location %p\n", rate, samples, index, location );
    if ((status = UNIX_CALL( glGetShadingRateSampleLocationivNV, &args ))) WARN( "glGetShadingRateSampleLocationivNV returned %#lx\n", status );
}

static void WINAPI glGetSharpenTexFuncSGIS( GLenum target, GLfloat *points )
{
    struct glGetSharpenTexFuncSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .points = points };
    NTSTATUS status;
    TRACE( "target %d, points %p\n", target, points );
    if ((status = UNIX_CALL( glGetSharpenTexFuncSGIS, &args ))) WARN( "glGetSharpenTexFuncSGIS returned %#lx\n", status );
}

static GLushort WINAPI glGetStageIndexNV( GLenum shadertype )
{
    struct glGetStageIndexNV_params args = { .teb = NtCurrentTeb(), .shadertype = shadertype };
    NTSTATUS status;
    TRACE( "shadertype %d\n", shadertype );
    if ((status = UNIX_CALL( glGetStageIndexNV, &args ))) WARN( "glGetStageIndexNV returned %#lx\n", status );
    return args.ret;
}

static GLuint WINAPI glGetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar *name )
{
    struct glGetSubroutineIndex_params args = { .teb = NtCurrentTeb(), .program = program, .shadertype = shadertype, .name = name };
    NTSTATUS status;
    TRACE( "program %d, shadertype %d, name %p\n", program, shadertype, name );
    if ((status = UNIX_CALL( glGetSubroutineIndex, &args ))) WARN( "glGetSubroutineIndex returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glGetSubroutineUniformLocation( GLuint program, GLenum shadertype, const GLchar *name )
{
    struct glGetSubroutineUniformLocation_params args = { .teb = NtCurrentTeb(), .program = program, .shadertype = shadertype, .name = name };
    NTSTATUS status;
    TRACE( "program %d, shadertype %d, name %p\n", program, shadertype, name );
    if ((status = UNIX_CALL( glGetSubroutineUniformLocation, &args ))) WARN( "glGetSubroutineUniformLocation returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetSynciv( GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values )
{
    struct glGetSynciv_params args = { .teb = NtCurrentTeb(), .sync = sync, .pname = pname, .count = count, .length = length, .values = values };
    NTSTATUS status;
    TRACE( "sync %p, pname %d, count %d, length %p, values %p\n", sync, pname, count, length, values );
    if ((status = UNIX_CALL( glGetSynciv, &args ))) WARN( "glGetSynciv returned %#lx\n", status );
}

static void WINAPI glGetTexBumpParameterfvATI( GLenum pname, GLfloat *param )
{
    struct glGetTexBumpParameterfvATI_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %p\n", pname, param );
    if ((status = UNIX_CALL( glGetTexBumpParameterfvATI, &args ))) WARN( "glGetTexBumpParameterfvATI returned %#lx\n", status );
}

static void WINAPI glGetTexBumpParameterivATI( GLenum pname, GLint *param )
{
    struct glGetTexBumpParameterivATI_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %p\n", pname, param );
    if ((status = UNIX_CALL( glGetTexBumpParameterivATI, &args ))) WARN( "glGetTexBumpParameterivATI returned %#lx\n", status );
}

static void WINAPI glGetTexEnvxvOES( GLenum target, GLenum pname, GLfixed *params )
{
    struct glGetTexEnvxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexEnvxvOES, &args ))) WARN( "glGetTexEnvxvOES returned %#lx\n", status );
}

static void WINAPI glGetTexFilterFuncSGIS( GLenum target, GLenum filter, GLfloat *weights )
{
    struct glGetTexFilterFuncSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .filter = filter, .weights = weights };
    NTSTATUS status;
    TRACE( "target %d, filter %d, weights %p\n", target, filter, weights );
    if ((status = UNIX_CALL( glGetTexFilterFuncSGIS, &args ))) WARN( "glGetTexFilterFuncSGIS returned %#lx\n", status );
}

static void WINAPI glGetTexGenxvOES( GLenum coord, GLenum pname, GLfixed *params )
{
    struct glGetTexGenxvOES_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
    if ((status = UNIX_CALL( glGetTexGenxvOES, &args ))) WARN( "glGetTexGenxvOES returned %#lx\n", status );
}

static void WINAPI glGetTexLevelParameterxvOES( GLenum target, GLint level, GLenum pname, GLfixed *params )
{
    struct glGetTexLevelParameterxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, level %d, pname %d, params %p\n", target, level, pname, params );
    if ((status = UNIX_CALL( glGetTexLevelParameterxvOES, &args ))) WARN( "glGetTexLevelParameterxvOES returned %#lx\n", status );
}

static void WINAPI glGetTexParameterIiv( GLenum target, GLenum pname, GLint *params )
{
    struct glGetTexParameterIiv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexParameterIiv, &args ))) WARN( "glGetTexParameterIiv returned %#lx\n", status );
}

static void WINAPI glGetTexParameterIivEXT( GLenum target, GLenum pname, GLint *params )
{
    struct glGetTexParameterIivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexParameterIivEXT, &args ))) WARN( "glGetTexParameterIivEXT returned %#lx\n", status );
}

static void WINAPI glGetTexParameterIuiv( GLenum target, GLenum pname, GLuint *params )
{
    struct glGetTexParameterIuiv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexParameterIuiv, &args ))) WARN( "glGetTexParameterIuiv returned %#lx\n", status );
}

static void WINAPI glGetTexParameterIuivEXT( GLenum target, GLenum pname, GLuint *params )
{
    struct glGetTexParameterIuivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexParameterIuivEXT, &args ))) WARN( "glGetTexParameterIuivEXT returned %#lx\n", status );
}

static void WINAPI glGetTexParameterPointervAPPLE( GLenum target, GLenum pname, void **params )
{
    struct glGetTexParameterPointervAPPLE_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexParameterPointervAPPLE, &args ))) WARN( "glGetTexParameterPointervAPPLE returned %#lx\n", status );
}

static void WINAPI glGetTexParameterxvOES( GLenum target, GLenum pname, GLfixed *params )
{
    struct glGetTexParameterxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glGetTexParameterxvOES, &args ))) WARN( "glGetTexParameterxvOES returned %#lx\n", status );
}

static GLuint64 WINAPI glGetTextureHandleARB( GLuint texture )
{
    struct glGetTextureHandleARB_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glGetTextureHandleARB, &args ))) WARN( "glGetTextureHandleARB returned %#lx\n", status );
    return args.ret;
}

static GLuint64 WINAPI glGetTextureHandleNV( GLuint texture )
{
    struct glGetTextureHandleNV_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glGetTextureHandleNV, &args ))) WARN( "glGetTextureHandleNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetTextureImage( GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels )
{
    struct glGetTextureImage_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .format = format, .type = type, .bufSize = bufSize, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, level %d, format %d, type %d, bufSize %d, pixels %p\n", texture, level, format, type, bufSize, pixels );
    if ((status = UNIX_CALL( glGetTextureImage, &args ))) WARN( "glGetTextureImage returned %#lx\n", status );
}

static void WINAPI glGetTextureImageEXT( GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
{
    struct glGetTextureImageEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, format %d, type %d, pixels %p\n", texture, target, level, format, type, pixels );
    if ((status = UNIX_CALL( glGetTextureImageEXT, &args ))) WARN( "glGetTextureImageEXT returned %#lx\n", status );
}

static void WINAPI glGetTextureLevelParameterfv( GLuint texture, GLint level, GLenum pname, GLfloat *params )
{
    struct glGetTextureLevelParameterfv_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, level %d, pname %d, params %p\n", texture, level, pname, params );
    if ((status = UNIX_CALL( glGetTextureLevelParameterfv, &args ))) WARN( "glGetTextureLevelParameterfv returned %#lx\n", status );
}

static void WINAPI glGetTextureLevelParameterfvEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params )
{
    struct glGetTextureLevelParameterfvEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, pname %d, params %p\n", texture, target, level, pname, params );
    if ((status = UNIX_CALL( glGetTextureLevelParameterfvEXT, &args ))) WARN( "glGetTextureLevelParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetTextureLevelParameteriv( GLuint texture, GLint level, GLenum pname, GLint *params )
{
    struct glGetTextureLevelParameteriv_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, level %d, pname %d, params %p\n", texture, level, pname, params );
    if ((status = UNIX_CALL( glGetTextureLevelParameteriv, &args ))) WARN( "glGetTextureLevelParameteriv returned %#lx\n", status );
}

static void WINAPI glGetTextureLevelParameterivEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params )
{
    struct glGetTextureLevelParameterivEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, pname %d, params %p\n", texture, target, level, pname, params );
    if ((status = UNIX_CALL( glGetTextureLevelParameterivEXT, &args ))) WARN( "glGetTextureLevelParameterivEXT returned %#lx\n", status );
}

static void WINAPI glGetTextureParameterIiv( GLuint texture, GLenum pname, GLint *params )
{
    struct glGetTextureParameterIiv_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, params %p\n", texture, pname, params );
    if ((status = UNIX_CALL( glGetTextureParameterIiv, &args ))) WARN( "glGetTextureParameterIiv returned %#lx\n", status );
}

static void WINAPI glGetTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, GLint *params )
{
    struct glGetTextureParameterIivEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, params %p\n", texture, target, pname, params );
    if ((status = UNIX_CALL( glGetTextureParameterIivEXT, &args ))) WARN( "glGetTextureParameterIivEXT returned %#lx\n", status );
}

static void WINAPI glGetTextureParameterIuiv( GLuint texture, GLenum pname, GLuint *params )
{
    struct glGetTextureParameterIuiv_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, params %p\n", texture, pname, params );
    if ((status = UNIX_CALL( glGetTextureParameterIuiv, &args ))) WARN( "glGetTextureParameterIuiv returned %#lx\n", status );
}

static void WINAPI glGetTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, GLuint *params )
{
    struct glGetTextureParameterIuivEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, params %p\n", texture, target, pname, params );
    if ((status = UNIX_CALL( glGetTextureParameterIuivEXT, &args ))) WARN( "glGetTextureParameterIuivEXT returned %#lx\n", status );
}

static void WINAPI glGetTextureParameterfv( GLuint texture, GLenum pname, GLfloat *params )
{
    struct glGetTextureParameterfv_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, params %p\n", texture, pname, params );
    if ((status = UNIX_CALL( glGetTextureParameterfv, &args ))) WARN( "glGetTextureParameterfv returned %#lx\n", status );
}

static void WINAPI glGetTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, GLfloat *params )
{
    struct glGetTextureParameterfvEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, params %p\n", texture, target, pname, params );
    if ((status = UNIX_CALL( glGetTextureParameterfvEXT, &args ))) WARN( "glGetTextureParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glGetTextureParameteriv( GLuint texture, GLenum pname, GLint *params )
{
    struct glGetTextureParameteriv_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, params %p\n", texture, pname, params );
    if ((status = UNIX_CALL( glGetTextureParameteriv, &args ))) WARN( "glGetTextureParameteriv returned %#lx\n", status );
}

static void WINAPI glGetTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, GLint *params )
{
    struct glGetTextureParameterivEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, params %p\n", texture, target, pname, params );
    if ((status = UNIX_CALL( glGetTextureParameterivEXT, &args ))) WARN( "glGetTextureParameterivEXT returned %#lx\n", status );
}

static GLuint64 WINAPI glGetTextureSamplerHandleARB( GLuint texture, GLuint sampler )
{
    struct glGetTextureSamplerHandleARB_params args = { .teb = NtCurrentTeb(), .texture = texture, .sampler = sampler };
    NTSTATUS status;
    TRACE( "texture %d, sampler %d\n", texture, sampler );
    if ((status = UNIX_CALL( glGetTextureSamplerHandleARB, &args ))) WARN( "glGetTextureSamplerHandleARB returned %#lx\n", status );
    return args.ret;
}

static GLuint64 WINAPI glGetTextureSamplerHandleNV( GLuint texture, GLuint sampler )
{
    struct glGetTextureSamplerHandleNV_params args = { .teb = NtCurrentTeb(), .texture = texture, .sampler = sampler };
    NTSTATUS status;
    TRACE( "texture %d, sampler %d\n", texture, sampler );
    if ((status = UNIX_CALL( glGetTextureSamplerHandleNV, &args ))) WARN( "glGetTextureSamplerHandleNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels )
{
    struct glGetTextureSubImage_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .type = type, .bufSize = bufSize, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, type %d, bufSize %d, pixels %p\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels );
    if ((status = UNIX_CALL( glGetTextureSubImage, &args ))) WARN( "glGetTextureSubImage returned %#lx\n", status );
}

static void WINAPI glGetTrackMatrixivNV( GLenum target, GLuint address, GLenum pname, GLint *params )
{
    struct glGetTrackMatrixivNV_params args = { .teb = NtCurrentTeb(), .target = target, .address = address, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, address %d, pname %d, params %p\n", target, address, pname, params );
    if ((status = UNIX_CALL( glGetTrackMatrixivNV, &args ))) WARN( "glGetTrackMatrixivNV returned %#lx\n", status );
}

static void WINAPI glGetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name )
{
    struct glGetTransformFeedbackVarying_params args = { .teb = NtCurrentTeb(), .program = program, .index = index, .bufSize = bufSize, .length = length, .size = size, .type = type, .name = name };
    NTSTATUS status;
    TRACE( "program %d, index %d, bufSize %d, length %p, size %p, type %p, name %p\n", program, index, bufSize, length, size, type, name );
    if ((status = UNIX_CALL( glGetTransformFeedbackVarying, &args ))) WARN( "glGetTransformFeedbackVarying returned %#lx\n", status );
}

static void WINAPI glGetTransformFeedbackVaryingEXT( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name )
{
    struct glGetTransformFeedbackVaryingEXT_params args = { .teb = NtCurrentTeb(), .program = program, .index = index, .bufSize = bufSize, .length = length, .size = size, .type = type, .name = name };
    NTSTATUS status;
    TRACE( "program %d, index %d, bufSize %d, length %p, size %p, type %p, name %p\n", program, index, bufSize, length, size, type, name );
    if ((status = UNIX_CALL( glGetTransformFeedbackVaryingEXT, &args ))) WARN( "glGetTransformFeedbackVaryingEXT returned %#lx\n", status );
}

static void WINAPI glGetTransformFeedbackVaryingNV( GLuint program, GLuint index, GLint *location )
{
    struct glGetTransformFeedbackVaryingNV_params args = { .teb = NtCurrentTeb(), .program = program, .index = index, .location = location };
    NTSTATUS status;
    TRACE( "program %d, index %d, location %p\n", program, index, location );
    if ((status = UNIX_CALL( glGetTransformFeedbackVaryingNV, &args ))) WARN( "glGetTransformFeedbackVaryingNV returned %#lx\n", status );
}

static void WINAPI glGetTransformFeedbacki64_v( GLuint xfb, GLenum pname, GLuint index, GLint64 *param )
{
    struct glGetTransformFeedbacki64_v_params args = { .teb = NtCurrentTeb(), .xfb = xfb, .pname = pname, .index = index, .param = param };
    NTSTATUS status;
    TRACE( "xfb %d, pname %d, index %d, param %p\n", xfb, pname, index, param );
    if ((status = UNIX_CALL( glGetTransformFeedbacki64_v, &args ))) WARN( "glGetTransformFeedbacki64_v returned %#lx\n", status );
}

static void WINAPI glGetTransformFeedbacki_v( GLuint xfb, GLenum pname, GLuint index, GLint *param )
{
    struct glGetTransformFeedbacki_v_params args = { .teb = NtCurrentTeb(), .xfb = xfb, .pname = pname, .index = index, .param = param };
    NTSTATUS status;
    TRACE( "xfb %d, pname %d, index %d, param %p\n", xfb, pname, index, param );
    if ((status = UNIX_CALL( glGetTransformFeedbacki_v, &args ))) WARN( "glGetTransformFeedbacki_v returned %#lx\n", status );
}

static void WINAPI glGetTransformFeedbackiv( GLuint xfb, GLenum pname, GLint *param )
{
    struct glGetTransformFeedbackiv_params args = { .teb = NtCurrentTeb(), .xfb = xfb, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "xfb %d, pname %d, param %p\n", xfb, pname, param );
    if ((status = UNIX_CALL( glGetTransformFeedbackiv, &args ))) WARN( "glGetTransformFeedbackiv returned %#lx\n", status );
}

static GLuint WINAPI glGetUniformBlockIndex( GLuint program, const GLchar *uniformBlockName )
{
    struct glGetUniformBlockIndex_params args = { .teb = NtCurrentTeb(), .program = program, .uniformBlockName = uniformBlockName };
    NTSTATUS status;
    TRACE( "program %d, uniformBlockName %p\n", program, uniformBlockName );
    if ((status = UNIX_CALL( glGetUniformBlockIndex, &args ))) WARN( "glGetUniformBlockIndex returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glGetUniformBufferSizeEXT( GLuint program, GLint location )
{
    struct glGetUniformBufferSizeEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location };
    NTSTATUS status;
    TRACE( "program %d, location %d\n", program, location );
    if ((status = UNIX_CALL( glGetUniformBufferSizeEXT, &args ))) WARN( "glGetUniformBufferSizeEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices )
{
    struct glGetUniformIndices_params args = { .teb = NtCurrentTeb(), .program = program, .uniformCount = uniformCount, .uniformNames = uniformNames, .uniformIndices = uniformIndices };
    NTSTATUS status;
    TRACE( "program %d, uniformCount %d, uniformNames %p, uniformIndices %p\n", program, uniformCount, uniformNames, uniformIndices );
    if ((status = UNIX_CALL( glGetUniformIndices, &args ))) WARN( "glGetUniformIndices returned %#lx\n", status );
}

static GLint WINAPI glGetUniformLocation( GLuint program, const GLchar *name )
{
    struct glGetUniformLocation_params args = { .teb = NtCurrentTeb(), .program = program, .name = name };
    NTSTATUS status;
    TRACE( "program %d, name %p\n", program, name );
    if ((status = UNIX_CALL( glGetUniformLocation, &args ))) WARN( "glGetUniformLocation returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glGetUniformLocationARB( GLhandleARB programObj, const GLcharARB *name )
{
    struct glGetUniformLocationARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj, .name = name };
    NTSTATUS status;
    TRACE( "programObj %d, name %p\n", programObj, name );
    if ((status = UNIX_CALL( glGetUniformLocationARB, &args ))) WARN( "glGetUniformLocationARB returned %#lx\n", status );
    return args.ret;
}

static GLintptr WINAPI glGetUniformOffsetEXT( GLuint program, GLint location )
{
    struct glGetUniformOffsetEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location };
    NTSTATUS status;
    TRACE( "program %d, location %d\n", program, location );
    if ((status = UNIX_CALL( glGetUniformOffsetEXT, &args ))) WARN( "glGetUniformOffsetEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint *params )
{
    struct glGetUniformSubroutineuiv_params args = { .teb = NtCurrentTeb(), .shadertype = shadertype, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "shadertype %d, location %d, params %p\n", shadertype, location, params );
    if ((status = UNIX_CALL( glGetUniformSubroutineuiv, &args ))) WARN( "glGetUniformSubroutineuiv returned %#lx\n", status );
}

static void WINAPI glGetUniformdv( GLuint program, GLint location, GLdouble *params )
{
    struct glGetUniformdv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformdv, &args ))) WARN( "glGetUniformdv returned %#lx\n", status );
}

static void WINAPI glGetUniformfv( GLuint program, GLint location, GLfloat *params )
{
    struct glGetUniformfv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformfv, &args ))) WARN( "glGetUniformfv returned %#lx\n", status );
}

static void WINAPI glGetUniformfvARB( GLhandleARB programObj, GLint location, GLfloat *params )
{
    struct glGetUniformfvARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "programObj %d, location %d, params %p\n", programObj, location, params );
    if ((status = UNIX_CALL( glGetUniformfvARB, &args ))) WARN( "glGetUniformfvARB returned %#lx\n", status );
}

static void WINAPI glGetUniformi64vARB( GLuint program, GLint location, GLint64 *params )
{
    struct glGetUniformi64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformi64vARB, &args ))) WARN( "glGetUniformi64vARB returned %#lx\n", status );
}

static void WINAPI glGetUniformi64vNV( GLuint program, GLint location, GLint64EXT *params )
{
    struct glGetUniformi64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformi64vNV, &args ))) WARN( "glGetUniformi64vNV returned %#lx\n", status );
}

static void WINAPI glGetUniformiv( GLuint program, GLint location, GLint *params )
{
    struct glGetUniformiv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformiv, &args ))) WARN( "glGetUniformiv returned %#lx\n", status );
}

static void WINAPI glGetUniformivARB( GLhandleARB programObj, GLint location, GLint *params )
{
    struct glGetUniformivARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "programObj %d, location %d, params %p\n", programObj, location, params );
    if ((status = UNIX_CALL( glGetUniformivARB, &args ))) WARN( "glGetUniformivARB returned %#lx\n", status );
}

static void WINAPI glGetUniformui64vARB( GLuint program, GLint location, GLuint64 *params )
{
    struct glGetUniformui64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformui64vARB, &args ))) WARN( "glGetUniformui64vARB returned %#lx\n", status );
}

static void WINAPI glGetUniformui64vNV( GLuint program, GLint location, GLuint64EXT *params )
{
    struct glGetUniformui64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformui64vNV, &args ))) WARN( "glGetUniformui64vNV returned %#lx\n", status );
}

static void WINAPI glGetUniformuiv( GLuint program, GLint location, GLuint *params )
{
    struct glGetUniformuiv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformuiv, &args ))) WARN( "glGetUniformuiv returned %#lx\n", status );
}

static void WINAPI glGetUniformuivEXT( GLuint program, GLint location, GLuint *params )
{
    struct glGetUniformuivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, params %p\n", program, location, params );
    if ((status = UNIX_CALL( glGetUniformuivEXT, &args ))) WARN( "glGetUniformuivEXT returned %#lx\n", status );
}

static void WINAPI glGetUnsignedBytei_vEXT( GLenum target, GLuint index, GLubyte *data )
{
    struct glGetUnsignedBytei_vEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .data = data };
    NTSTATUS status;
    TRACE( "target %d, index %d, data %p\n", target, index, data );
    if ((status = UNIX_CALL( glGetUnsignedBytei_vEXT, &args ))) WARN( "glGetUnsignedBytei_vEXT returned %#lx\n", status );
}

static void WINAPI glGetUnsignedBytevEXT( GLenum pname, GLubyte *data )
{
    struct glGetUnsignedBytevEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .data = data };
    NTSTATUS status;
    TRACE( "pname %d, data %p\n", pname, data );
    if ((status = UNIX_CALL( glGetUnsignedBytevEXT, &args ))) WARN( "glGetUnsignedBytevEXT returned %#lx\n", status );
}

static void WINAPI glGetVariantArrayObjectfvATI( GLuint id, GLenum pname, GLfloat *params )
{
    struct glGetVariantArrayObjectfvATI_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetVariantArrayObjectfvATI, &args ))) WARN( "glGetVariantArrayObjectfvATI returned %#lx\n", status );
}

static void WINAPI glGetVariantArrayObjectivATI( GLuint id, GLenum pname, GLint *params )
{
    struct glGetVariantArrayObjectivATI_params args = { .teb = NtCurrentTeb(), .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "id %d, pname %d, params %p\n", id, pname, params );
    if ((status = UNIX_CALL( glGetVariantArrayObjectivATI, &args ))) WARN( "glGetVariantArrayObjectivATI returned %#lx\n", status );
}

static void WINAPI glGetVariantBooleanvEXT( GLuint id, GLenum value, GLboolean *data )
{
    struct glGetVariantBooleanvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetVariantBooleanvEXT, &args ))) WARN( "glGetVariantBooleanvEXT returned %#lx\n", status );
}

static void WINAPI glGetVariantFloatvEXT( GLuint id, GLenum value, GLfloat *data )
{
    struct glGetVariantFloatvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetVariantFloatvEXT, &args ))) WARN( "glGetVariantFloatvEXT returned %#lx\n", status );
}

static void WINAPI glGetVariantIntegervEXT( GLuint id, GLenum value, GLint *data )
{
    struct glGetVariantIntegervEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetVariantIntegervEXT, &args ))) WARN( "glGetVariantIntegervEXT returned %#lx\n", status );
}

static void WINAPI glGetVariantPointervEXT( GLuint id, GLenum value, void **data )
{
    struct glGetVariantPointervEXT_params args = { .teb = NtCurrentTeb(), .id = id, .value = value, .data = data };
    NTSTATUS status;
    TRACE( "id %d, value %d, data %p\n", id, value, data );
    if ((status = UNIX_CALL( glGetVariantPointervEXT, &args ))) WARN( "glGetVariantPointervEXT returned %#lx\n", status );
}

static GLint WINAPI glGetVaryingLocationNV( GLuint program, const GLchar *name )
{
    struct glGetVaryingLocationNV_params args = { .teb = NtCurrentTeb(), .program = program, .name = name };
    NTSTATUS status;
    TRACE( "program %d, name %p\n", program, name );
    if ((status = UNIX_CALL( glGetVaryingLocationNV, &args ))) WARN( "glGetVaryingLocationNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetVertexArrayIndexed64iv( GLuint vaobj, GLuint index, GLenum pname, GLint64 *param )
{
    struct glGetVertexArrayIndexed64iv_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d, pname %d, param %p\n", vaobj, index, pname, param );
    if ((status = UNIX_CALL( glGetVertexArrayIndexed64iv, &args ))) WARN( "glGetVertexArrayIndexed64iv returned %#lx\n", status );
}

static void WINAPI glGetVertexArrayIndexediv( GLuint vaobj, GLuint index, GLenum pname, GLint *param )
{
    struct glGetVertexArrayIndexediv_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d, pname %d, param %p\n", vaobj, index, pname, param );
    if ((status = UNIX_CALL( glGetVertexArrayIndexediv, &args ))) WARN( "glGetVertexArrayIndexediv returned %#lx\n", status );
}

static void WINAPI glGetVertexArrayIntegeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, GLint *param )
{
    struct glGetVertexArrayIntegeri_vEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d, pname %d, param %p\n", vaobj, index, pname, param );
    if ((status = UNIX_CALL( glGetVertexArrayIntegeri_vEXT, &args ))) WARN( "glGetVertexArrayIntegeri_vEXT returned %#lx\n", status );
}

static void WINAPI glGetVertexArrayIntegervEXT( GLuint vaobj, GLenum pname, GLint *param )
{
    struct glGetVertexArrayIntegervEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "vaobj %d, pname %d, param %p\n", vaobj, pname, param );
    if ((status = UNIX_CALL( glGetVertexArrayIntegervEXT, &args ))) WARN( "glGetVertexArrayIntegervEXT returned %#lx\n", status );
}

static void WINAPI glGetVertexArrayPointeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, void **param )
{
    struct glGetVertexArrayPointeri_vEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d, pname %d, param %p\n", vaobj, index, pname, param );
    if ((status = UNIX_CALL( glGetVertexArrayPointeri_vEXT, &args ))) WARN( "glGetVertexArrayPointeri_vEXT returned %#lx\n", status );
}

static void WINAPI glGetVertexArrayPointervEXT( GLuint vaobj, GLenum pname, void **param )
{
    struct glGetVertexArrayPointervEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "vaobj %d, pname %d, param %p\n", vaobj, pname, param );
    if ((status = UNIX_CALL( glGetVertexArrayPointervEXT, &args ))) WARN( "glGetVertexArrayPointervEXT returned %#lx\n", status );
}

static void WINAPI glGetVertexArrayiv( GLuint vaobj, GLenum pname, GLint *param )
{
    struct glGetVertexArrayiv_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "vaobj %d, pname %d, param %p\n", vaobj, pname, param );
    if ((status = UNIX_CALL( glGetVertexArrayiv, &args ))) WARN( "glGetVertexArrayiv returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribArrayObjectfvATI( GLuint index, GLenum pname, GLfloat *params )
{
    struct glGetVertexAttribArrayObjectfvATI_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribArrayObjectfvATI, &args ))) WARN( "glGetVertexAttribArrayObjectfvATI returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribArrayObjectivATI( GLuint index, GLenum pname, GLint *params )
{
    struct glGetVertexAttribArrayObjectivATI_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribArrayObjectivATI, &args ))) WARN( "glGetVertexAttribArrayObjectivATI returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribIiv( GLuint index, GLenum pname, GLint *params )
{
    struct glGetVertexAttribIiv_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribIiv, &args ))) WARN( "glGetVertexAttribIiv returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribIivEXT( GLuint index, GLenum pname, GLint *params )
{
    struct glGetVertexAttribIivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribIivEXT, &args ))) WARN( "glGetVertexAttribIivEXT returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint *params )
{
    struct glGetVertexAttribIuiv_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribIuiv, &args ))) WARN( "glGetVertexAttribIuiv returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribIuivEXT( GLuint index, GLenum pname, GLuint *params )
{
    struct glGetVertexAttribIuivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribIuivEXT, &args ))) WARN( "glGetVertexAttribIuivEXT returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribLdv( GLuint index, GLenum pname, GLdouble *params )
{
    struct glGetVertexAttribLdv_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribLdv, &args ))) WARN( "glGetVertexAttribLdv returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribLdvEXT( GLuint index, GLenum pname, GLdouble *params )
{
    struct glGetVertexAttribLdvEXT_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribLdvEXT, &args ))) WARN( "glGetVertexAttribLdvEXT returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribLi64vNV( GLuint index, GLenum pname, GLint64EXT *params )
{
    struct glGetVertexAttribLi64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribLi64vNV, &args ))) WARN( "glGetVertexAttribLi64vNV returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribLui64vARB( GLuint index, GLenum pname, GLuint64EXT *params )
{
    struct glGetVertexAttribLui64vARB_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribLui64vARB, &args ))) WARN( "glGetVertexAttribLui64vARB returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribLui64vNV( GLuint index, GLenum pname, GLuint64EXT *params )
{
    struct glGetVertexAttribLui64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribLui64vNV, &args ))) WARN( "glGetVertexAttribLui64vNV returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribPointerv( GLuint index, GLenum pname, void **pointer )
{
    struct glGetVertexAttribPointerv_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, pname %d, pointer %p\n", index, pname, pointer );
    if ((status = UNIX_CALL( glGetVertexAttribPointerv, &args ))) WARN( "glGetVertexAttribPointerv returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribPointervARB( GLuint index, GLenum pname, void **pointer )
{
    struct glGetVertexAttribPointervARB_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, pname %d, pointer %p\n", index, pname, pointer );
    if ((status = UNIX_CALL( glGetVertexAttribPointervARB, &args ))) WARN( "glGetVertexAttribPointervARB returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribPointervNV( GLuint index, GLenum pname, void **pointer )
{
    struct glGetVertexAttribPointervNV_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, pname %d, pointer %p\n", index, pname, pointer );
    if ((status = UNIX_CALL( glGetVertexAttribPointervNV, &args ))) WARN( "glGetVertexAttribPointervNV returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribdv( GLuint index, GLenum pname, GLdouble *params )
{
    struct glGetVertexAttribdv_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribdv, &args ))) WARN( "glGetVertexAttribdv returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribdvARB( GLuint index, GLenum pname, GLdouble *params )
{
    struct glGetVertexAttribdvARB_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribdvARB, &args ))) WARN( "glGetVertexAttribdvARB returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribdvNV( GLuint index, GLenum pname, GLdouble *params )
{
    struct glGetVertexAttribdvNV_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribdvNV, &args ))) WARN( "glGetVertexAttribdvNV returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribfv( GLuint index, GLenum pname, GLfloat *params )
{
    struct glGetVertexAttribfv_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribfv, &args ))) WARN( "glGetVertexAttribfv returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribfvARB( GLuint index, GLenum pname, GLfloat *params )
{
    struct glGetVertexAttribfvARB_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribfvARB, &args ))) WARN( "glGetVertexAttribfvARB returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribfvNV( GLuint index, GLenum pname, GLfloat *params )
{
    struct glGetVertexAttribfvNV_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribfvNV, &args ))) WARN( "glGetVertexAttribfvNV returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribiv( GLuint index, GLenum pname, GLint *params )
{
    struct glGetVertexAttribiv_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribiv, &args ))) WARN( "glGetVertexAttribiv returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribivARB( GLuint index, GLenum pname, GLint *params )
{
    struct glGetVertexAttribivARB_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribivARB, &args ))) WARN( "glGetVertexAttribivARB returned %#lx\n", status );
}

static void WINAPI glGetVertexAttribivNV( GLuint index, GLenum pname, GLint *params )
{
    struct glGetVertexAttribivNV_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "index %d, pname %d, params %p\n", index, pname, params );
    if ((status = UNIX_CALL( glGetVertexAttribivNV, &args ))) WARN( "glGetVertexAttribivNV returned %#lx\n", status );
}

static void WINAPI glGetVideoCaptureStreamdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params )
{
    struct glGetVideoCaptureStreamdvNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .stream = stream, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, stream %d, pname %d, params %p\n", video_capture_slot, stream, pname, params );
    if ((status = UNIX_CALL( glGetVideoCaptureStreamdvNV, &args ))) WARN( "glGetVideoCaptureStreamdvNV returned %#lx\n", status );
}

static void WINAPI glGetVideoCaptureStreamfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params )
{
    struct glGetVideoCaptureStreamfvNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .stream = stream, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, stream %d, pname %d, params %p\n", video_capture_slot, stream, pname, params );
    if ((status = UNIX_CALL( glGetVideoCaptureStreamfvNV, &args ))) WARN( "glGetVideoCaptureStreamfvNV returned %#lx\n", status );
}

static void WINAPI glGetVideoCaptureStreamivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params )
{
    struct glGetVideoCaptureStreamivNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .stream = stream, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, stream %d, pname %d, params %p\n", video_capture_slot, stream, pname, params );
    if ((status = UNIX_CALL( glGetVideoCaptureStreamivNV, &args ))) WARN( "glGetVideoCaptureStreamivNV returned %#lx\n", status );
}

static void WINAPI glGetVideoCaptureivNV( GLuint video_capture_slot, GLenum pname, GLint *params )
{
    struct glGetVideoCaptureivNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, pname %d, params %p\n", video_capture_slot, pname, params );
    if ((status = UNIX_CALL( glGetVideoCaptureivNV, &args ))) WARN( "glGetVideoCaptureivNV returned %#lx\n", status );
}

static void WINAPI glGetVideoi64vNV( GLuint video_slot, GLenum pname, GLint64EXT *params )
{
    struct glGetVideoi64vNV_params args = { .teb = NtCurrentTeb(), .video_slot = video_slot, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_slot %d, pname %d, params %p\n", video_slot, pname, params );
    if ((status = UNIX_CALL( glGetVideoi64vNV, &args ))) WARN( "glGetVideoi64vNV returned %#lx\n", status );
}

static void WINAPI glGetVideoivNV( GLuint video_slot, GLenum pname, GLint *params )
{
    struct glGetVideoivNV_params args = { .teb = NtCurrentTeb(), .video_slot = video_slot, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_slot %d, pname %d, params %p\n", video_slot, pname, params );
    if ((status = UNIX_CALL( glGetVideoivNV, &args ))) WARN( "glGetVideoivNV returned %#lx\n", status );
}

static void WINAPI glGetVideoui64vNV( GLuint video_slot, GLenum pname, GLuint64EXT *params )
{
    struct glGetVideoui64vNV_params args = { .teb = NtCurrentTeb(), .video_slot = video_slot, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_slot %d, pname %d, params %p\n", video_slot, pname, params );
    if ((status = UNIX_CALL( glGetVideoui64vNV, &args ))) WARN( "glGetVideoui64vNV returned %#lx\n", status );
}

static void WINAPI glGetVideouivNV( GLuint video_slot, GLenum pname, GLuint *params )
{
    struct glGetVideouivNV_params args = { .teb = NtCurrentTeb(), .video_slot = video_slot, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_slot %d, pname %d, params %p\n", video_slot, pname, params );
    if ((status = UNIX_CALL( glGetVideouivNV, &args ))) WARN( "glGetVideouivNV returned %#lx\n", status );
}

static GLVULKANPROCNV WINAPI glGetVkProcAddrNV( const GLchar *name )
{
    struct glGetVkProcAddrNV_params args = { .teb = NtCurrentTeb(), .name = name };
    NTSTATUS status;
    TRACE( "name %p\n", name );
    if ((status = UNIX_CALL( glGetVkProcAddrNV, &args ))) WARN( "glGetVkProcAddrNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glGetnColorTable( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table )
{
    struct glGetnColorTable_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .bufSize = bufSize, .table = table };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, bufSize %d, table %p\n", target, format, type, bufSize, table );
    if ((status = UNIX_CALL( glGetnColorTable, &args ))) WARN( "glGetnColorTable returned %#lx\n", status );
}

static void WINAPI glGetnColorTableARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table )
{
    struct glGetnColorTableARB_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .bufSize = bufSize, .table = table };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, bufSize %d, table %p\n", target, format, type, bufSize, table );
    if ((status = UNIX_CALL( glGetnColorTableARB, &args ))) WARN( "glGetnColorTableARB returned %#lx\n", status );
}

static void WINAPI glGetnCompressedTexImage( GLenum target, GLint lod, GLsizei bufSize, void *pixels )
{
    struct glGetnCompressedTexImage_params args = { .teb = NtCurrentTeb(), .target = target, .lod = lod, .bufSize = bufSize, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, lod %d, bufSize %d, pixels %p\n", target, lod, bufSize, pixels );
    if ((status = UNIX_CALL( glGetnCompressedTexImage, &args ))) WARN( "glGetnCompressedTexImage returned %#lx\n", status );
}

static void WINAPI glGetnCompressedTexImageARB( GLenum target, GLint lod, GLsizei bufSize, void *img )
{
    struct glGetnCompressedTexImageARB_params args = { .teb = NtCurrentTeb(), .target = target, .lod = lod, .bufSize = bufSize, .img = img };
    NTSTATUS status;
    TRACE( "target %d, lod %d, bufSize %d, img %p\n", target, lod, bufSize, img );
    if ((status = UNIX_CALL( glGetnCompressedTexImageARB, &args ))) WARN( "glGetnCompressedTexImageARB returned %#lx\n", status );
}

static void WINAPI glGetnConvolutionFilter( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image )
{
    struct glGetnConvolutionFilter_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .bufSize = bufSize, .image = image };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, bufSize %d, image %p\n", target, format, type, bufSize, image );
    if ((status = UNIX_CALL( glGetnConvolutionFilter, &args ))) WARN( "glGetnConvolutionFilter returned %#lx\n", status );
}

static void WINAPI glGetnConvolutionFilterARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image )
{
    struct glGetnConvolutionFilterARB_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .bufSize = bufSize, .image = image };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, bufSize %d, image %p\n", target, format, type, bufSize, image );
    if ((status = UNIX_CALL( glGetnConvolutionFilterARB, &args ))) WARN( "glGetnConvolutionFilterARB returned %#lx\n", status );
}

static void WINAPI glGetnHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values )
{
    struct glGetnHistogram_params args = { .teb = NtCurrentTeb(), .target = target, .reset = reset, .format = format, .type = type, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "target %d, reset %d, format %d, type %d, bufSize %d, values %p\n", target, reset, format, type, bufSize, values );
    if ((status = UNIX_CALL( glGetnHistogram, &args ))) WARN( "glGetnHistogram returned %#lx\n", status );
}

static void WINAPI glGetnHistogramARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values )
{
    struct glGetnHistogramARB_params args = { .teb = NtCurrentTeb(), .target = target, .reset = reset, .format = format, .type = type, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "target %d, reset %d, format %d, type %d, bufSize %d, values %p\n", target, reset, format, type, bufSize, values );
    if ((status = UNIX_CALL( glGetnHistogramARB, &args ))) WARN( "glGetnHistogramARB returned %#lx\n", status );
}

static void WINAPI glGetnMapdv( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v )
{
    struct glGetnMapdv_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .bufSize = bufSize, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, bufSize %d, v %p\n", target, query, bufSize, v );
    if ((status = UNIX_CALL( glGetnMapdv, &args ))) WARN( "glGetnMapdv returned %#lx\n", status );
}

static void WINAPI glGetnMapdvARB( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v )
{
    struct glGetnMapdvARB_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .bufSize = bufSize, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, bufSize %d, v %p\n", target, query, bufSize, v );
    if ((status = UNIX_CALL( glGetnMapdvARB, &args ))) WARN( "glGetnMapdvARB returned %#lx\n", status );
}

static void WINAPI glGetnMapfv( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v )
{
    struct glGetnMapfv_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .bufSize = bufSize, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, bufSize %d, v %p\n", target, query, bufSize, v );
    if ((status = UNIX_CALL( glGetnMapfv, &args ))) WARN( "glGetnMapfv returned %#lx\n", status );
}

static void WINAPI glGetnMapfvARB( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v )
{
    struct glGetnMapfvARB_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .bufSize = bufSize, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, bufSize %d, v %p\n", target, query, bufSize, v );
    if ((status = UNIX_CALL( glGetnMapfvARB, &args ))) WARN( "glGetnMapfvARB returned %#lx\n", status );
}

static void WINAPI glGetnMapiv( GLenum target, GLenum query, GLsizei bufSize, GLint *v )
{
    struct glGetnMapiv_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .bufSize = bufSize, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, bufSize %d, v %p\n", target, query, bufSize, v );
    if ((status = UNIX_CALL( glGetnMapiv, &args ))) WARN( "glGetnMapiv returned %#lx\n", status );
}

static void WINAPI glGetnMapivARB( GLenum target, GLenum query, GLsizei bufSize, GLint *v )
{
    struct glGetnMapivARB_params args = { .teb = NtCurrentTeb(), .target = target, .query = query, .bufSize = bufSize, .v = v };
    NTSTATUS status;
    TRACE( "target %d, query %d, bufSize %d, v %p\n", target, query, bufSize, v );
    if ((status = UNIX_CALL( glGetnMapivARB, &args ))) WARN( "glGetnMapivARB returned %#lx\n", status );
}

static void WINAPI glGetnMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values )
{
    struct glGetnMinmax_params args = { .teb = NtCurrentTeb(), .target = target, .reset = reset, .format = format, .type = type, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "target %d, reset %d, format %d, type %d, bufSize %d, values %p\n", target, reset, format, type, bufSize, values );
    if ((status = UNIX_CALL( glGetnMinmax, &args ))) WARN( "glGetnMinmax returned %#lx\n", status );
}

static void WINAPI glGetnMinmaxARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values )
{
    struct glGetnMinmaxARB_params args = { .teb = NtCurrentTeb(), .target = target, .reset = reset, .format = format, .type = type, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "target %d, reset %d, format %d, type %d, bufSize %d, values %p\n", target, reset, format, type, bufSize, values );
    if ((status = UNIX_CALL( glGetnMinmaxARB, &args ))) WARN( "glGetnMinmaxARB returned %#lx\n", status );
}

static void WINAPI glGetnPixelMapfv( GLenum map, GLsizei bufSize, GLfloat *values )
{
    struct glGetnPixelMapfv_params args = { .teb = NtCurrentTeb(), .map = map, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, bufSize %d, values %p\n", map, bufSize, values );
    if ((status = UNIX_CALL( glGetnPixelMapfv, &args ))) WARN( "glGetnPixelMapfv returned %#lx\n", status );
}

static void WINAPI glGetnPixelMapfvARB( GLenum map, GLsizei bufSize, GLfloat *values )
{
    struct glGetnPixelMapfvARB_params args = { .teb = NtCurrentTeb(), .map = map, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, bufSize %d, values %p\n", map, bufSize, values );
    if ((status = UNIX_CALL( glGetnPixelMapfvARB, &args ))) WARN( "glGetnPixelMapfvARB returned %#lx\n", status );
}

static void WINAPI glGetnPixelMapuiv( GLenum map, GLsizei bufSize, GLuint *values )
{
    struct glGetnPixelMapuiv_params args = { .teb = NtCurrentTeb(), .map = map, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, bufSize %d, values %p\n", map, bufSize, values );
    if ((status = UNIX_CALL( glGetnPixelMapuiv, &args ))) WARN( "glGetnPixelMapuiv returned %#lx\n", status );
}

static void WINAPI glGetnPixelMapuivARB( GLenum map, GLsizei bufSize, GLuint *values )
{
    struct glGetnPixelMapuivARB_params args = { .teb = NtCurrentTeb(), .map = map, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, bufSize %d, values %p\n", map, bufSize, values );
    if ((status = UNIX_CALL( glGetnPixelMapuivARB, &args ))) WARN( "glGetnPixelMapuivARB returned %#lx\n", status );
}

static void WINAPI glGetnPixelMapusv( GLenum map, GLsizei bufSize, GLushort *values )
{
    struct glGetnPixelMapusv_params args = { .teb = NtCurrentTeb(), .map = map, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, bufSize %d, values %p\n", map, bufSize, values );
    if ((status = UNIX_CALL( glGetnPixelMapusv, &args ))) WARN( "glGetnPixelMapusv returned %#lx\n", status );
}

static void WINAPI glGetnPixelMapusvARB( GLenum map, GLsizei bufSize, GLushort *values )
{
    struct glGetnPixelMapusvARB_params args = { .teb = NtCurrentTeb(), .map = map, .bufSize = bufSize, .values = values };
    NTSTATUS status;
    TRACE( "map %d, bufSize %d, values %p\n", map, bufSize, values );
    if ((status = UNIX_CALL( glGetnPixelMapusvARB, &args ))) WARN( "glGetnPixelMapusvARB returned %#lx\n", status );
}

static void WINAPI glGetnPolygonStipple( GLsizei bufSize, GLubyte *pattern )
{
    struct glGetnPolygonStipple_params args = { .teb = NtCurrentTeb(), .bufSize = bufSize, .pattern = pattern };
    NTSTATUS status;
    TRACE( "bufSize %d, pattern %p\n", bufSize, pattern );
    if ((status = UNIX_CALL( glGetnPolygonStipple, &args ))) WARN( "glGetnPolygonStipple returned %#lx\n", status );
}

static void WINAPI glGetnPolygonStippleARB( GLsizei bufSize, GLubyte *pattern )
{
    struct glGetnPolygonStippleARB_params args = { .teb = NtCurrentTeb(), .bufSize = bufSize, .pattern = pattern };
    NTSTATUS status;
    TRACE( "bufSize %d, pattern %p\n", bufSize, pattern );
    if ((status = UNIX_CALL( glGetnPolygonStippleARB, &args ))) WARN( "glGetnPolygonStippleARB returned %#lx\n", status );
}

static void WINAPI glGetnSeparableFilter( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span )
{
    struct glGetnSeparableFilter_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .rowBufSize = rowBufSize, .row = row, .columnBufSize = columnBufSize, .column = column, .span = span };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, rowBufSize %d, row %p, columnBufSize %d, column %p, span %p\n", target, format, type, rowBufSize, row, columnBufSize, column, span );
    if ((status = UNIX_CALL( glGetnSeparableFilter, &args ))) WARN( "glGetnSeparableFilter returned %#lx\n", status );
}

static void WINAPI glGetnSeparableFilterARB( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span )
{
    struct glGetnSeparableFilterARB_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .type = type, .rowBufSize = rowBufSize, .row = row, .columnBufSize = columnBufSize, .column = column, .span = span };
    NTSTATUS status;
    TRACE( "target %d, format %d, type %d, rowBufSize %d, row %p, columnBufSize %d, column %p, span %p\n", target, format, type, rowBufSize, row, columnBufSize, column, span );
    if ((status = UNIX_CALL( glGetnSeparableFilterARB, &args ))) WARN( "glGetnSeparableFilterARB returned %#lx\n", status );
}

static void WINAPI glGetnTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels )
{
    struct glGetnTexImage_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .format = format, .type = type, .bufSize = bufSize, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, format %d, type %d, bufSize %d, pixels %p\n", target, level, format, type, bufSize, pixels );
    if ((status = UNIX_CALL( glGetnTexImage, &args ))) WARN( "glGetnTexImage returned %#lx\n", status );
}

static void WINAPI glGetnTexImageARB( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *img )
{
    struct glGetnTexImageARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .format = format, .type = type, .bufSize = bufSize, .img = img };
    NTSTATUS status;
    TRACE( "target %d, level %d, format %d, type %d, bufSize %d, img %p\n", target, level, format, type, bufSize, img );
    if ((status = UNIX_CALL( glGetnTexImageARB, &args ))) WARN( "glGetnTexImageARB returned %#lx\n", status );
}

static void WINAPI glGetnUniformdv( GLuint program, GLint location, GLsizei bufSize, GLdouble *params )
{
    struct glGetnUniformdv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformdv, &args ))) WARN( "glGetnUniformdv returned %#lx\n", status );
}

static void WINAPI glGetnUniformdvARB( GLuint program, GLint location, GLsizei bufSize, GLdouble *params )
{
    struct glGetnUniformdvARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformdvARB, &args ))) WARN( "glGetnUniformdvARB returned %#lx\n", status );
}

static void WINAPI glGetnUniformfv( GLuint program, GLint location, GLsizei bufSize, GLfloat *params )
{
    struct glGetnUniformfv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformfv, &args ))) WARN( "glGetnUniformfv returned %#lx\n", status );
}

static void WINAPI glGetnUniformfvARB( GLuint program, GLint location, GLsizei bufSize, GLfloat *params )
{
    struct glGetnUniformfvARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformfvARB, &args ))) WARN( "glGetnUniformfvARB returned %#lx\n", status );
}

static void WINAPI glGetnUniformi64vARB( GLuint program, GLint location, GLsizei bufSize, GLint64 *params )
{
    struct glGetnUniformi64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformi64vARB, &args ))) WARN( "glGetnUniformi64vARB returned %#lx\n", status );
}

static void WINAPI glGetnUniformiv( GLuint program, GLint location, GLsizei bufSize, GLint *params )
{
    struct glGetnUniformiv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformiv, &args ))) WARN( "glGetnUniformiv returned %#lx\n", status );
}

static void WINAPI glGetnUniformivARB( GLuint program, GLint location, GLsizei bufSize, GLint *params )
{
    struct glGetnUniformivARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformivARB, &args ))) WARN( "glGetnUniformivARB returned %#lx\n", status );
}

static void WINAPI glGetnUniformui64vARB( GLuint program, GLint location, GLsizei bufSize, GLuint64 *params )
{
    struct glGetnUniformui64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformui64vARB, &args ))) WARN( "glGetnUniformui64vARB returned %#lx\n", status );
}

static void WINAPI glGetnUniformuiv( GLuint program, GLint location, GLsizei bufSize, GLuint *params )
{
    struct glGetnUniformuiv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformuiv, &args ))) WARN( "glGetnUniformuiv returned %#lx\n", status );
}

static void WINAPI glGetnUniformuivARB( GLuint program, GLint location, GLsizei bufSize, GLuint *params )
{
    struct glGetnUniformuivARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .bufSize = bufSize, .params = params };
    NTSTATUS status;
    TRACE( "program %d, location %d, bufSize %d, params %p\n", program, location, bufSize, params );
    if ((status = UNIX_CALL( glGetnUniformuivARB, &args ))) WARN( "glGetnUniformuivARB returned %#lx\n", status );
}

static void WINAPI glGlobalAlphaFactorbSUN( GLbyte factor )
{
    struct glGlobalAlphaFactorbSUN_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %d\n", factor );
    if ((status = UNIX_CALL( glGlobalAlphaFactorbSUN, &args ))) WARN( "glGlobalAlphaFactorbSUN returned %#lx\n", status );
}

static void WINAPI glGlobalAlphaFactordSUN( GLdouble factor )
{
    struct glGlobalAlphaFactordSUN_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %f\n", factor );
    if ((status = UNIX_CALL( glGlobalAlphaFactordSUN, &args ))) WARN( "glGlobalAlphaFactordSUN returned %#lx\n", status );
}

static void WINAPI glGlobalAlphaFactorfSUN( GLfloat factor )
{
    struct glGlobalAlphaFactorfSUN_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %f\n", factor );
    if ((status = UNIX_CALL( glGlobalAlphaFactorfSUN, &args ))) WARN( "glGlobalAlphaFactorfSUN returned %#lx\n", status );
}

static void WINAPI glGlobalAlphaFactoriSUN( GLint factor )
{
    struct glGlobalAlphaFactoriSUN_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %d\n", factor );
    if ((status = UNIX_CALL( glGlobalAlphaFactoriSUN, &args ))) WARN( "glGlobalAlphaFactoriSUN returned %#lx\n", status );
}

static void WINAPI glGlobalAlphaFactorsSUN( GLshort factor )
{
    struct glGlobalAlphaFactorsSUN_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %d\n", factor );
    if ((status = UNIX_CALL( glGlobalAlphaFactorsSUN, &args ))) WARN( "glGlobalAlphaFactorsSUN returned %#lx\n", status );
}

static void WINAPI glGlobalAlphaFactorubSUN( GLubyte factor )
{
    struct glGlobalAlphaFactorubSUN_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %d\n", factor );
    if ((status = UNIX_CALL( glGlobalAlphaFactorubSUN, &args ))) WARN( "glGlobalAlphaFactorubSUN returned %#lx\n", status );
}

static void WINAPI glGlobalAlphaFactoruiSUN( GLuint factor )
{
    struct glGlobalAlphaFactoruiSUN_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %d\n", factor );
    if ((status = UNIX_CALL( glGlobalAlphaFactoruiSUN, &args ))) WARN( "glGlobalAlphaFactoruiSUN returned %#lx\n", status );
}

static void WINAPI glGlobalAlphaFactorusSUN( GLushort factor )
{
    struct glGlobalAlphaFactorusSUN_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %d\n", factor );
    if ((status = UNIX_CALL( glGlobalAlphaFactorusSUN, &args ))) WARN( "glGlobalAlphaFactorusSUN returned %#lx\n", status );
}

static void WINAPI glHintPGI( GLenum target, GLint mode )
{
    struct glHintPGI_params args = { .teb = NtCurrentTeb(), .target = target, .mode = mode };
    NTSTATUS status;
    TRACE( "target %d, mode %d\n", target, mode );
    if ((status = UNIX_CALL( glHintPGI, &args ))) WARN( "glHintPGI returned %#lx\n", status );
}

static void WINAPI glHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink )
{
    struct glHistogram_params args = { .teb = NtCurrentTeb(), .target = target, .width = width, .internalformat = internalformat, .sink = sink };
    NTSTATUS status;
    TRACE( "target %d, width %d, internalformat %d, sink %d\n", target, width, internalformat, sink );
    if ((status = UNIX_CALL( glHistogram, &args ))) WARN( "glHistogram returned %#lx\n", status );
}

static void WINAPI glHistogramEXT( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink )
{
    struct glHistogramEXT_params args = { .teb = NtCurrentTeb(), .target = target, .width = width, .internalformat = internalformat, .sink = sink };
    NTSTATUS status;
    TRACE( "target %d, width %d, internalformat %d, sink %d\n", target, width, internalformat, sink );
    if ((status = UNIX_CALL( glHistogramEXT, &args ))) WARN( "glHistogramEXT returned %#lx\n", status );
}

static void WINAPI glIglooInterfaceSGIX( GLenum pname, const void *params )
{
    struct glIglooInterfaceSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glIglooInterfaceSGIX, &args ))) WARN( "glIglooInterfaceSGIX returned %#lx\n", status );
}

static void WINAPI glImageTransformParameterfHP( GLenum target, GLenum pname, GLfloat param )
{
    struct glImageTransformParameterfHP_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %f\n", target, pname, param );
    if ((status = UNIX_CALL( glImageTransformParameterfHP, &args ))) WARN( "glImageTransformParameterfHP returned %#lx\n", status );
}

static void WINAPI glImageTransformParameterfvHP( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glImageTransformParameterfvHP_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glImageTransformParameterfvHP, &args ))) WARN( "glImageTransformParameterfvHP returned %#lx\n", status );
}

static void WINAPI glImageTransformParameteriHP( GLenum target, GLenum pname, GLint param )
{
    struct glImageTransformParameteriHP_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glImageTransformParameteriHP, &args ))) WARN( "glImageTransformParameteriHP returned %#lx\n", status );
}

static void WINAPI glImageTransformParameterivHP( GLenum target, GLenum pname, const GLint *params )
{
    struct glImageTransformParameterivHP_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glImageTransformParameterivHP, &args ))) WARN( "glImageTransformParameterivHP returned %#lx\n", status );
}

static void WINAPI glImportMemoryFdEXT( GLuint memory, GLuint64 size, GLenum handleType, GLint fd )
{
    struct glImportMemoryFdEXT_params args = { .teb = NtCurrentTeb(), .memory = memory, .size = size, .handleType = handleType, .fd = fd };
    NTSTATUS status;
    TRACE( "memory %d, size %s, handleType %d, fd %d\n", memory, wine_dbgstr_longlong(size), handleType, fd );
    if ((status = UNIX_CALL( glImportMemoryFdEXT, &args ))) WARN( "glImportMemoryFdEXT returned %#lx\n", status );
}

static void WINAPI glImportMemoryWin32HandleEXT( GLuint memory, GLuint64 size, GLenum handleType, void *handle )
{
    struct glImportMemoryWin32HandleEXT_params args = { .teb = NtCurrentTeb(), .memory = memory, .size = size, .handleType = handleType, .handle = handle };
    NTSTATUS status;
    TRACE( "memory %d, size %s, handleType %d, handle %p\n", memory, wine_dbgstr_longlong(size), handleType, handle );
    if ((status = UNIX_CALL( glImportMemoryWin32HandleEXT, &args ))) WARN( "glImportMemoryWin32HandleEXT returned %#lx\n", status );
}

static void WINAPI glImportMemoryWin32NameEXT( GLuint memory, GLuint64 size, GLenum handleType, const void *name )
{
    struct glImportMemoryWin32NameEXT_params args = { .teb = NtCurrentTeb(), .memory = memory, .size = size, .handleType = handleType, .name = name };
    NTSTATUS status;
    TRACE( "memory %d, size %s, handleType %d, name %p\n", memory, wine_dbgstr_longlong(size), handleType, name );
    if ((status = UNIX_CALL( glImportMemoryWin32NameEXT, &args ))) WARN( "glImportMemoryWin32NameEXT returned %#lx\n", status );
}

static void WINAPI glImportSemaphoreFdEXT( GLuint semaphore, GLenum handleType, GLint fd )
{
    struct glImportSemaphoreFdEXT_params args = { .teb = NtCurrentTeb(), .semaphore = semaphore, .handleType = handleType, .fd = fd };
    NTSTATUS status;
    TRACE( "semaphore %d, handleType %d, fd %d\n", semaphore, handleType, fd );
    if ((status = UNIX_CALL( glImportSemaphoreFdEXT, &args ))) WARN( "glImportSemaphoreFdEXT returned %#lx\n", status );
}

static void WINAPI glImportSemaphoreWin32HandleEXT( GLuint semaphore, GLenum handleType, void *handle )
{
    struct glImportSemaphoreWin32HandleEXT_params args = { .teb = NtCurrentTeb(), .semaphore = semaphore, .handleType = handleType, .handle = handle };
    NTSTATUS status;
    TRACE( "semaphore %d, handleType %d, handle %p\n", semaphore, handleType, handle );
    if ((status = UNIX_CALL( glImportSemaphoreWin32HandleEXT, &args ))) WARN( "glImportSemaphoreWin32HandleEXT returned %#lx\n", status );
}

static void WINAPI glImportSemaphoreWin32NameEXT( GLuint semaphore, GLenum handleType, const void *name )
{
    struct glImportSemaphoreWin32NameEXT_params args = { .teb = NtCurrentTeb(), .semaphore = semaphore, .handleType = handleType, .name = name };
    NTSTATUS status;
    TRACE( "semaphore %d, handleType %d, name %p\n", semaphore, handleType, name );
    if ((status = UNIX_CALL( glImportSemaphoreWin32NameEXT, &args ))) WARN( "glImportSemaphoreWin32NameEXT returned %#lx\n", status );
}

static GLsync WINAPI glImportSyncEXT( GLenum external_sync_type, GLintptr external_sync, GLbitfield flags )
{
    struct glImportSyncEXT_params args = { .teb = NtCurrentTeb(), .external_sync_type = external_sync_type, .external_sync = external_sync, .flags = flags };
    NTSTATUS status;
    TRACE( "external_sync_type %d, external_sync %Id, flags %d\n", external_sync_type, external_sync, flags );
    if ((status = UNIX_CALL( glImportSyncEXT, &args ))) WARN( "glImportSyncEXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glIndexFormatNV( GLenum type, GLsizei stride )
{
    struct glIndexFormatNV_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "type %d, stride %d\n", type, stride );
    if ((status = UNIX_CALL( glIndexFormatNV, &args ))) WARN( "glIndexFormatNV returned %#lx\n", status );
}

static void WINAPI glIndexFuncEXT( GLenum func, GLclampf ref )
{
    struct glIndexFuncEXT_params args = { .teb = NtCurrentTeb(), .func = func, .ref = ref };
    NTSTATUS status;
    TRACE( "func %d, ref %f\n", func, ref );
    if ((status = UNIX_CALL( glIndexFuncEXT, &args ))) WARN( "glIndexFuncEXT returned %#lx\n", status );
}

static void WINAPI glIndexMaterialEXT( GLenum face, GLenum mode )
{
    struct glIndexMaterialEXT_params args = { .teb = NtCurrentTeb(), .face = face, .mode = mode };
    NTSTATUS status;
    TRACE( "face %d, mode %d\n", face, mode );
    if ((status = UNIX_CALL( glIndexMaterialEXT, &args ))) WARN( "glIndexMaterialEXT returned %#lx\n", status );
}

static void WINAPI glIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void *pointer )
{
    struct glIndexPointerEXT_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .count = count, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, count %d, pointer %p\n", type, stride, count, pointer );
    if ((status = UNIX_CALL( glIndexPointerEXT, &args ))) WARN( "glIndexPointerEXT returned %#lx\n", status );
}

static void WINAPI glIndexPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride )
{
    struct glIndexPointerListIBM_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer, .ptrstride = ptrstride };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p, ptrstride %d\n", type, stride, pointer, ptrstride );
    if ((status = UNIX_CALL( glIndexPointerListIBM, &args ))) WARN( "glIndexPointerListIBM returned %#lx\n", status );
}

static void WINAPI glIndexxOES( GLfixed component )
{
    struct glIndexxOES_params args = { .teb = NtCurrentTeb(), .component = component };
    NTSTATUS status;
    TRACE( "component %d\n", component );
    if ((status = UNIX_CALL( glIndexxOES, &args ))) WARN( "glIndexxOES returned %#lx\n", status );
}

static void WINAPI glIndexxvOES( const GLfixed *component )
{
    struct glIndexxvOES_params args = { .teb = NtCurrentTeb(), .component = component };
    NTSTATUS status;
    TRACE( "component %p\n", component );
    if ((status = UNIX_CALL( glIndexxvOES, &args ))) WARN( "glIndexxvOES returned %#lx\n", status );
}

static void WINAPI glInsertComponentEXT( GLuint res, GLuint src, GLuint num )
{
    struct glInsertComponentEXT_params args = { .teb = NtCurrentTeb(), .res = res, .src = src, .num = num };
    NTSTATUS status;
    TRACE( "res %d, src %d, num %d\n", res, src, num );
    if ((status = UNIX_CALL( glInsertComponentEXT, &args ))) WARN( "glInsertComponentEXT returned %#lx\n", status );
}

static void WINAPI glInsertEventMarkerEXT( GLsizei length, const GLchar *marker )
{
    struct glInsertEventMarkerEXT_params args = { .teb = NtCurrentTeb(), .length = length, .marker = marker };
    NTSTATUS status;
    TRACE( "length %d, marker %p\n", length, marker );
    if ((status = UNIX_CALL( glInsertEventMarkerEXT, &args ))) WARN( "glInsertEventMarkerEXT returned %#lx\n", status );
}

static void WINAPI glInstrumentsBufferSGIX( GLsizei size, GLint *buffer )
{
    struct glInstrumentsBufferSGIX_params args = { .teb = NtCurrentTeb(), .size = size, .buffer = buffer };
    NTSTATUS status;
    TRACE( "size %d, buffer %p\n", size, buffer );
    if ((status = UNIX_CALL( glInstrumentsBufferSGIX, &args ))) WARN( "glInstrumentsBufferSGIX returned %#lx\n", status );
}

static void WINAPI glInterpolatePathsNV( GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight )
{
    struct glInterpolatePathsNV_params args = { .teb = NtCurrentTeb(), .resultPath = resultPath, .pathA = pathA, .pathB = pathB, .weight = weight };
    NTSTATUS status;
    TRACE( "resultPath %d, pathA %d, pathB %d, weight %f\n", resultPath, pathA, pathB, weight );
    if ((status = UNIX_CALL( glInterpolatePathsNV, &args ))) WARN( "glInterpolatePathsNV returned %#lx\n", status );
}

static void WINAPI glInvalidateBufferData( GLuint buffer )
{
    struct glInvalidateBufferData_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glInvalidateBufferData, &args ))) WARN( "glInvalidateBufferData returned %#lx\n", status );
}

static void WINAPI glInvalidateBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr length )
{
    struct glInvalidateBufferSubData_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .length = length };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, length %Id\n", buffer, offset, length );
    if ((status = UNIX_CALL( glInvalidateBufferSubData, &args ))) WARN( "glInvalidateBufferSubData returned %#lx\n", status );
}

static void WINAPI glInvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum *attachments )
{
    struct glInvalidateFramebuffer_params args = { .teb = NtCurrentTeb(), .target = target, .numAttachments = numAttachments, .attachments = attachments };
    NTSTATUS status;
    TRACE( "target %d, numAttachments %d, attachments %p\n", target, numAttachments, attachments );
    if ((status = UNIX_CALL( glInvalidateFramebuffer, &args ))) WARN( "glInvalidateFramebuffer returned %#lx\n", status );
}

static void WINAPI glInvalidateNamedFramebufferData( GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments )
{
    struct glInvalidateNamedFramebufferData_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .numAttachments = numAttachments, .attachments = attachments };
    NTSTATUS status;
    TRACE( "framebuffer %d, numAttachments %d, attachments %p\n", framebuffer, numAttachments, attachments );
    if ((status = UNIX_CALL( glInvalidateNamedFramebufferData, &args ))) WARN( "glInvalidateNamedFramebufferData returned %#lx\n", status );
}

static void WINAPI glInvalidateNamedFramebufferSubData( GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glInvalidateNamedFramebufferSubData_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .numAttachments = numAttachments, .attachments = attachments, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "framebuffer %d, numAttachments %d, attachments %p, x %d, y %d, width %d, height %d\n", framebuffer, numAttachments, attachments, x, y, width, height );
    if ((status = UNIX_CALL( glInvalidateNamedFramebufferSubData, &args ))) WARN( "glInvalidateNamedFramebufferSubData returned %#lx\n", status );
}

static void WINAPI glInvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glInvalidateSubFramebuffer_params args = { .teb = NtCurrentTeb(), .target = target, .numAttachments = numAttachments, .attachments = attachments, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, numAttachments %d, attachments %p, x %d, y %d, width %d, height %d\n", target, numAttachments, attachments, x, y, width, height );
    if ((status = UNIX_CALL( glInvalidateSubFramebuffer, &args ))) WARN( "glInvalidateSubFramebuffer returned %#lx\n", status );
}

static void WINAPI glInvalidateTexImage( GLuint texture, GLint level )
{
    struct glInvalidateTexImage_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "texture %d, level %d\n", texture, level );
    if ((status = UNIX_CALL( glInvalidateTexImage, &args ))) WARN( "glInvalidateTexImage returned %#lx\n", status );
}

static void WINAPI glInvalidateTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth )
{
    struct glInvalidateTexSubImage_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d\n", texture, level, xoffset, yoffset, zoffset, width, height, depth );
    if ((status = UNIX_CALL( glInvalidateTexSubImage, &args ))) WARN( "glInvalidateTexSubImage returned %#lx\n", status );
}

static GLboolean WINAPI glIsAsyncMarkerSGIX( GLuint marker )
{
    struct glIsAsyncMarkerSGIX_params args = { .teb = NtCurrentTeb(), .marker = marker };
    NTSTATUS status;
    TRACE( "marker %d\n", marker );
    if ((status = UNIX_CALL( glIsAsyncMarkerSGIX, &args ))) WARN( "glIsAsyncMarkerSGIX returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsBuffer( GLuint buffer )
{
    struct glIsBuffer_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glIsBuffer, &args ))) WARN( "glIsBuffer returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsBufferARB( GLuint buffer )
{
    struct glIsBufferARB_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glIsBufferARB, &args ))) WARN( "glIsBufferARB returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsBufferResidentNV( GLenum target )
{
    struct glIsBufferResidentNV_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glIsBufferResidentNV, &args ))) WARN( "glIsBufferResidentNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsCommandListNV( GLuint list )
{
    struct glIsCommandListNV_params args = { .teb = NtCurrentTeb(), .list = list };
    NTSTATUS status;
    TRACE( "list %d\n", list );
    if ((status = UNIX_CALL( glIsCommandListNV, &args ))) WARN( "glIsCommandListNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsEnabledIndexedEXT( GLenum target, GLuint index )
{
    struct glIsEnabledIndexedEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index };
    NTSTATUS status;
    TRACE( "target %d, index %d\n", target, index );
    if ((status = UNIX_CALL( glIsEnabledIndexedEXT, &args ))) WARN( "glIsEnabledIndexedEXT returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsEnabledi( GLenum target, GLuint index )
{
    struct glIsEnabledi_params args = { .teb = NtCurrentTeb(), .target = target, .index = index };
    NTSTATUS status;
    TRACE( "target %d, index %d\n", target, index );
    if ((status = UNIX_CALL( glIsEnabledi, &args ))) WARN( "glIsEnabledi returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsFenceAPPLE( GLuint fence )
{
    struct glIsFenceAPPLE_params args = { .teb = NtCurrentTeb(), .fence = fence };
    NTSTATUS status;
    TRACE( "fence %d\n", fence );
    if ((status = UNIX_CALL( glIsFenceAPPLE, &args ))) WARN( "glIsFenceAPPLE returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsFenceNV( GLuint fence )
{
    struct glIsFenceNV_params args = { .teb = NtCurrentTeb(), .fence = fence };
    NTSTATUS status;
    TRACE( "fence %d\n", fence );
    if ((status = UNIX_CALL( glIsFenceNV, &args ))) WARN( "glIsFenceNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsFramebuffer( GLuint framebuffer )
{
    struct glIsFramebuffer_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer };
    NTSTATUS status;
    TRACE( "framebuffer %d\n", framebuffer );
    if ((status = UNIX_CALL( glIsFramebuffer, &args ))) WARN( "glIsFramebuffer returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsFramebufferEXT( GLuint framebuffer )
{
    struct glIsFramebufferEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer };
    NTSTATUS status;
    TRACE( "framebuffer %d\n", framebuffer );
    if ((status = UNIX_CALL( glIsFramebufferEXT, &args ))) WARN( "glIsFramebufferEXT returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsImageHandleResidentARB( GLuint64 handle )
{
    struct glIsImageHandleResidentARB_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glIsImageHandleResidentARB, &args ))) WARN( "glIsImageHandleResidentARB returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsImageHandleResidentNV( GLuint64 handle )
{
    struct glIsImageHandleResidentNV_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glIsImageHandleResidentNV, &args ))) WARN( "glIsImageHandleResidentNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsMemoryObjectEXT( GLuint memoryObject )
{
    struct glIsMemoryObjectEXT_params args = { .teb = NtCurrentTeb(), .memoryObject = memoryObject };
    NTSTATUS status;
    TRACE( "memoryObject %d\n", memoryObject );
    if ((status = UNIX_CALL( glIsMemoryObjectEXT, &args ))) WARN( "glIsMemoryObjectEXT returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsNameAMD( GLenum identifier, GLuint name )
{
    struct glIsNameAMD_params args = { .teb = NtCurrentTeb(), .identifier = identifier, .name = name };
    NTSTATUS status;
    TRACE( "identifier %d, name %d\n", identifier, name );
    if ((status = UNIX_CALL( glIsNameAMD, &args ))) WARN( "glIsNameAMD returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsNamedBufferResidentNV( GLuint buffer )
{
    struct glIsNamedBufferResidentNV_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glIsNamedBufferResidentNV, &args ))) WARN( "glIsNamedBufferResidentNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsNamedStringARB( GLint namelen, const GLchar *name )
{
    struct glIsNamedStringARB_params args = { .teb = NtCurrentTeb(), .namelen = namelen, .name = name };
    NTSTATUS status;
    TRACE( "namelen %d, name %p\n", namelen, name );
    if ((status = UNIX_CALL( glIsNamedStringARB, &args ))) WARN( "glIsNamedStringARB returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsObjectBufferATI( GLuint buffer )
{
    struct glIsObjectBufferATI_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glIsObjectBufferATI, &args ))) WARN( "glIsObjectBufferATI returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsOcclusionQueryNV( GLuint id )
{
    struct glIsOcclusionQueryNV_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glIsOcclusionQueryNV, &args ))) WARN( "glIsOcclusionQueryNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsPathNV( GLuint path )
{
    struct glIsPathNV_params args = { .teb = NtCurrentTeb(), .path = path };
    NTSTATUS status;
    TRACE( "path %d\n", path );
    if ((status = UNIX_CALL( glIsPathNV, &args ))) WARN( "glIsPathNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsPointInFillPathNV( GLuint path, GLuint mask, GLfloat x, GLfloat y )
{
    struct glIsPointInFillPathNV_params args = { .teb = NtCurrentTeb(), .path = path, .mask = mask, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "path %d, mask %d, x %f, y %f\n", path, mask, x, y );
    if ((status = UNIX_CALL( glIsPointInFillPathNV, &args ))) WARN( "glIsPointInFillPathNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsPointInStrokePathNV( GLuint path, GLfloat x, GLfloat y )
{
    struct glIsPointInStrokePathNV_params args = { .teb = NtCurrentTeb(), .path = path, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "path %d, x %f, y %f\n", path, x, y );
    if ((status = UNIX_CALL( glIsPointInStrokePathNV, &args ))) WARN( "glIsPointInStrokePathNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsProgram( GLuint program )
{
    struct glIsProgram_params args = { .teb = NtCurrentTeb(), .program = program };
    NTSTATUS status;
    TRACE( "program %d\n", program );
    if ((status = UNIX_CALL( glIsProgram, &args ))) WARN( "glIsProgram returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsProgramARB( GLuint program )
{
    struct glIsProgramARB_params args = { .teb = NtCurrentTeb(), .program = program };
    NTSTATUS status;
    TRACE( "program %d\n", program );
    if ((status = UNIX_CALL( glIsProgramARB, &args ))) WARN( "glIsProgramARB returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsProgramNV( GLuint id )
{
    struct glIsProgramNV_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glIsProgramNV, &args ))) WARN( "glIsProgramNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsProgramPipeline( GLuint pipeline )
{
    struct glIsProgramPipeline_params args = { .teb = NtCurrentTeb(), .pipeline = pipeline };
    NTSTATUS status;
    TRACE( "pipeline %d\n", pipeline );
    if ((status = UNIX_CALL( glIsProgramPipeline, &args ))) WARN( "glIsProgramPipeline returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsQuery( GLuint id )
{
    struct glIsQuery_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glIsQuery, &args ))) WARN( "glIsQuery returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsQueryARB( GLuint id )
{
    struct glIsQueryARB_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glIsQueryARB, &args ))) WARN( "glIsQueryARB returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsRenderbuffer( GLuint renderbuffer )
{
    struct glIsRenderbuffer_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "renderbuffer %d\n", renderbuffer );
    if ((status = UNIX_CALL( glIsRenderbuffer, &args ))) WARN( "glIsRenderbuffer returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsRenderbufferEXT( GLuint renderbuffer )
{
    struct glIsRenderbufferEXT_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "renderbuffer %d\n", renderbuffer );
    if ((status = UNIX_CALL( glIsRenderbufferEXT, &args ))) WARN( "glIsRenderbufferEXT returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsSampler( GLuint sampler )
{
    struct glIsSampler_params args = { .teb = NtCurrentTeb(), .sampler = sampler };
    NTSTATUS status;
    TRACE( "sampler %d\n", sampler );
    if ((status = UNIX_CALL( glIsSampler, &args ))) WARN( "glIsSampler returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsSemaphoreEXT( GLuint semaphore )
{
    struct glIsSemaphoreEXT_params args = { .teb = NtCurrentTeb(), .semaphore = semaphore };
    NTSTATUS status;
    TRACE( "semaphore %d\n", semaphore );
    if ((status = UNIX_CALL( glIsSemaphoreEXT, &args ))) WARN( "glIsSemaphoreEXT returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsShader( GLuint shader )
{
    struct glIsShader_params args = { .teb = NtCurrentTeb(), .shader = shader };
    NTSTATUS status;
    TRACE( "shader %d\n", shader );
    if ((status = UNIX_CALL( glIsShader, &args ))) WARN( "glIsShader returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsStateNV( GLuint state )
{
    struct glIsStateNV_params args = { .teb = NtCurrentTeb(), .state = state };
    NTSTATUS status;
    TRACE( "state %d\n", state );
    if ((status = UNIX_CALL( glIsStateNV, &args ))) WARN( "glIsStateNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsSync( GLsync sync )
{
    struct glIsSync_params args = { .teb = NtCurrentTeb(), .sync = sync };
    NTSTATUS status;
    TRACE( "sync %p\n", sync );
    if ((status = UNIX_CALL( glIsSync, &args ))) WARN( "glIsSync returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsTextureEXT( GLuint texture )
{
    struct glIsTextureEXT_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glIsTextureEXT, &args ))) WARN( "glIsTextureEXT returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsTextureHandleResidentARB( GLuint64 handle )
{
    struct glIsTextureHandleResidentARB_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glIsTextureHandleResidentARB, &args ))) WARN( "glIsTextureHandleResidentARB returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsTextureHandleResidentNV( GLuint64 handle )
{
    struct glIsTextureHandleResidentNV_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glIsTextureHandleResidentNV, &args ))) WARN( "glIsTextureHandleResidentNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsTransformFeedback( GLuint id )
{
    struct glIsTransformFeedback_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glIsTransformFeedback, &args ))) WARN( "glIsTransformFeedback returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsTransformFeedbackNV( GLuint id )
{
    struct glIsTransformFeedbackNV_params args = { .teb = NtCurrentTeb(), .id = id };
    NTSTATUS status;
    TRACE( "id %d\n", id );
    if ((status = UNIX_CALL( glIsTransformFeedbackNV, &args ))) WARN( "glIsTransformFeedbackNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsVariantEnabledEXT( GLuint id, GLenum cap )
{
    struct glIsVariantEnabledEXT_params args = { .teb = NtCurrentTeb(), .id = id, .cap = cap };
    NTSTATUS status;
    TRACE( "id %d, cap %d\n", id, cap );
    if ((status = UNIX_CALL( glIsVariantEnabledEXT, &args ))) WARN( "glIsVariantEnabledEXT returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsVertexArray( GLuint array )
{
    struct glIsVertexArray_params args = { .teb = NtCurrentTeb(), .array = array };
    NTSTATUS status;
    TRACE( "array %d\n", array );
    if ((status = UNIX_CALL( glIsVertexArray, &args ))) WARN( "glIsVertexArray returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsVertexArrayAPPLE( GLuint array )
{
    struct glIsVertexArrayAPPLE_params args = { .teb = NtCurrentTeb(), .array = array };
    NTSTATUS status;
    TRACE( "array %d\n", array );
    if ((status = UNIX_CALL( glIsVertexArrayAPPLE, &args ))) WARN( "glIsVertexArrayAPPLE returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glIsVertexAttribEnabledAPPLE( GLuint index, GLenum pname )
{
    struct glIsVertexAttribEnabledAPPLE_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname };
    NTSTATUS status;
    TRACE( "index %d, pname %d\n", index, pname );
    if ((status = UNIX_CALL( glIsVertexAttribEnabledAPPLE, &args ))) WARN( "glIsVertexAttribEnabledAPPLE returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glLGPUCopyImageSubDataNVX( GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srxY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth )
{
    struct glLGPUCopyImageSubDataNVX_params args = { .teb = NtCurrentTeb(), .sourceGpu = sourceGpu, .destinationGpuMask = destinationGpuMask, .srcName = srcName, .srcTarget = srcTarget, .srcLevel = srcLevel, .srcX = srcX, .srxY = srxY, .srcZ = srcZ, .dstName = dstName, .dstTarget = dstTarget, .dstLevel = dstLevel, .dstX = dstX, .dstY = dstY, .dstZ = dstZ, .width = width, .height = height, .depth = depth };
    NTSTATUS status;
    TRACE( "sourceGpu %d, destinationGpuMask %d, srcName %d, srcTarget %d, srcLevel %d, srcX %d, srxY %d, srcZ %d, dstName %d, dstTarget %d, dstLevel %d, dstX %d, dstY %d, dstZ %d, width %d, height %d, depth %d\n", sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth );
    if ((status = UNIX_CALL( glLGPUCopyImageSubDataNVX, &args ))) WARN( "glLGPUCopyImageSubDataNVX returned %#lx\n", status );
}

static void WINAPI glLGPUInterlockNVX(void)
{
    struct glLGPUInterlockNVX_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glLGPUInterlockNVX, &args ))) WARN( "glLGPUInterlockNVX returned %#lx\n", status );
}

static void WINAPI glLGPUNamedBufferSubDataNVX( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data )
{
    struct glLGPUNamedBufferSubDataNVX_params args = { .teb = NtCurrentTeb(), .gpuMask = gpuMask, .buffer = buffer, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "gpuMask %d, buffer %d, offset %Id, size %Id, data %p\n", gpuMask, buffer, offset, size, data );
    if ((status = UNIX_CALL( glLGPUNamedBufferSubDataNVX, &args ))) WARN( "glLGPUNamedBufferSubDataNVX returned %#lx\n", status );
}

static void WINAPI glLabelObjectEXT( GLenum type, GLuint object, GLsizei length, const GLchar *label )
{
    struct glLabelObjectEXT_params args = { .teb = NtCurrentTeb(), .type = type, .object = object, .length = length, .label = label };
    NTSTATUS status;
    TRACE( "type %d, object %d, length %d, label %p\n", type, object, length, label );
    if ((status = UNIX_CALL( glLabelObjectEXT, &args ))) WARN( "glLabelObjectEXT returned %#lx\n", status );
}

static void WINAPI glLightEnviSGIX( GLenum pname, GLint param )
{
    struct glLightEnviSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glLightEnviSGIX, &args ))) WARN( "glLightEnviSGIX returned %#lx\n", status );
}

static void WINAPI glLightModelxOES( GLenum pname, GLfixed param )
{
    struct glLightModelxOES_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glLightModelxOES, &args ))) WARN( "glLightModelxOES returned %#lx\n", status );
}

static void WINAPI glLightModelxvOES( GLenum pname, const GLfixed *param )
{
    struct glLightModelxvOES_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %p\n", pname, param );
    if ((status = UNIX_CALL( glLightModelxvOES, &args ))) WARN( "glLightModelxvOES returned %#lx\n", status );
}

static void WINAPI glLightxOES( GLenum light, GLenum pname, GLfixed param )
{
    struct glLightxOES_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "light %d, pname %d, param %d\n", light, pname, param );
    if ((status = UNIX_CALL( glLightxOES, &args ))) WARN( "glLightxOES returned %#lx\n", status );
}

static void WINAPI glLightxvOES( GLenum light, GLenum pname, const GLfixed *params )
{
    struct glLightxvOES_params args = { .teb = NtCurrentTeb(), .light = light, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
    if ((status = UNIX_CALL( glLightxvOES, &args ))) WARN( "glLightxvOES returned %#lx\n", status );
}

static void WINAPI glLineWidthxOES( GLfixed width )
{
    struct glLineWidthxOES_params args = { .teb = NtCurrentTeb(), .width = width };
    NTSTATUS status;
    TRACE( "width %d\n", width );
    if ((status = UNIX_CALL( glLineWidthxOES, &args ))) WARN( "glLineWidthxOES returned %#lx\n", status );
}

static void WINAPI glLinkProgram( GLuint program )
{
    struct glLinkProgram_params args = { .teb = NtCurrentTeb(), .program = program };
    NTSTATUS status;
    TRACE( "program %d\n", program );
    if ((status = UNIX_CALL( glLinkProgram, &args ))) WARN( "glLinkProgram returned %#lx\n", status );
}

static void WINAPI glLinkProgramARB( GLhandleARB programObj )
{
    struct glLinkProgramARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj };
    NTSTATUS status;
    TRACE( "programObj %d\n", programObj );
    if ((status = UNIX_CALL( glLinkProgramARB, &args ))) WARN( "glLinkProgramARB returned %#lx\n", status );
}

static void WINAPI glListDrawCommandsStatesClientNV( GLuint list, GLuint segment, const void **indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count )
{
    struct glListDrawCommandsStatesClientNV_params args = { .teb = NtCurrentTeb(), .list = list, .segment = segment, .indirects = indirects, .sizes = sizes, .states = states, .fbos = fbos, .count = count };
    NTSTATUS status;
    TRACE( "list %d, segment %d, indirects %p, sizes %p, states %p, fbos %p, count %d\n", list, segment, indirects, sizes, states, fbos, count );
    if ((status = UNIX_CALL( glListDrawCommandsStatesClientNV, &args ))) WARN( "glListDrawCommandsStatesClientNV returned %#lx\n", status );
}

static void WINAPI glListParameterfSGIX( GLuint list, GLenum pname, GLfloat param )
{
    struct glListParameterfSGIX_params args = { .teb = NtCurrentTeb(), .list = list, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "list %d, pname %d, param %f\n", list, pname, param );
    if ((status = UNIX_CALL( glListParameterfSGIX, &args ))) WARN( "glListParameterfSGIX returned %#lx\n", status );
}

static void WINAPI glListParameterfvSGIX( GLuint list, GLenum pname, const GLfloat *params )
{
    struct glListParameterfvSGIX_params args = { .teb = NtCurrentTeb(), .list = list, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "list %d, pname %d, params %p\n", list, pname, params );
    if ((status = UNIX_CALL( glListParameterfvSGIX, &args ))) WARN( "glListParameterfvSGIX returned %#lx\n", status );
}

static void WINAPI glListParameteriSGIX( GLuint list, GLenum pname, GLint param )
{
    struct glListParameteriSGIX_params args = { .teb = NtCurrentTeb(), .list = list, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "list %d, pname %d, param %d\n", list, pname, param );
    if ((status = UNIX_CALL( glListParameteriSGIX, &args ))) WARN( "glListParameteriSGIX returned %#lx\n", status );
}

static void WINAPI glListParameterivSGIX( GLuint list, GLenum pname, const GLint *params )
{
    struct glListParameterivSGIX_params args = { .teb = NtCurrentTeb(), .list = list, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "list %d, pname %d, params %p\n", list, pname, params );
    if ((status = UNIX_CALL( glListParameterivSGIX, &args ))) WARN( "glListParameterivSGIX returned %#lx\n", status );
}

static void WINAPI glLoadIdentityDeformationMapSGIX( GLbitfield mask )
{
    struct glLoadIdentityDeformationMapSGIX_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glLoadIdentityDeformationMapSGIX, &args ))) WARN( "glLoadIdentityDeformationMapSGIX returned %#lx\n", status );
}

static void WINAPI glLoadMatrixxOES( const GLfixed *m )
{
    struct glLoadMatrixxOES_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glLoadMatrixxOES, &args ))) WARN( "glLoadMatrixxOES returned %#lx\n", status );
}

static void WINAPI glLoadProgramNV( GLenum target, GLuint id, GLsizei len, const GLubyte *program )
{
    struct glLoadProgramNV_params args = { .teb = NtCurrentTeb(), .target = target, .id = id, .len = len, .program = program };
    NTSTATUS status;
    TRACE( "target %d, id %d, len %d, program %p\n", target, id, len, program );
    if ((status = UNIX_CALL( glLoadProgramNV, &args ))) WARN( "glLoadProgramNV returned %#lx\n", status );
}

static void WINAPI glLoadTransposeMatrixd( const GLdouble *m )
{
    struct glLoadTransposeMatrixd_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glLoadTransposeMatrixd, &args ))) WARN( "glLoadTransposeMatrixd returned %#lx\n", status );
}

static void WINAPI glLoadTransposeMatrixdARB( const GLdouble *m )
{
    struct glLoadTransposeMatrixdARB_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glLoadTransposeMatrixdARB, &args ))) WARN( "glLoadTransposeMatrixdARB returned %#lx\n", status );
}

static void WINAPI glLoadTransposeMatrixf( const GLfloat *m )
{
    struct glLoadTransposeMatrixf_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glLoadTransposeMatrixf, &args ))) WARN( "glLoadTransposeMatrixf returned %#lx\n", status );
}

static void WINAPI glLoadTransposeMatrixfARB( const GLfloat *m )
{
    struct glLoadTransposeMatrixfARB_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glLoadTransposeMatrixfARB, &args ))) WARN( "glLoadTransposeMatrixfARB returned %#lx\n", status );
}

static void WINAPI glLoadTransposeMatrixxOES( const GLfixed *m )
{
    struct glLoadTransposeMatrixxOES_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glLoadTransposeMatrixxOES, &args ))) WARN( "glLoadTransposeMatrixxOES returned %#lx\n", status );
}

static void WINAPI glLockArraysEXT( GLint first, GLsizei count )
{
    struct glLockArraysEXT_params args = { .teb = NtCurrentTeb(), .first = first, .count = count };
    NTSTATUS status;
    TRACE( "first %d, count %d\n", first, count );
    if ((status = UNIX_CALL( glLockArraysEXT, &args ))) WARN( "glLockArraysEXT returned %#lx\n", status );
}

static void WINAPI glMTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t )
{
    struct glMTexCoord2fSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f\n", target, s, t );
    if ((status = UNIX_CALL( glMTexCoord2fSGIS, &args ))) WARN( "glMTexCoord2fSGIS returned %#lx\n", status );
}

static void WINAPI glMTexCoord2fvSGIS( GLenum target, GLfloat * v )
{
    struct glMTexCoord2fvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMTexCoord2fvSGIS, &args ))) WARN( "glMTexCoord2fvSGIS returned %#lx\n", status );
}

static void WINAPI glMakeBufferNonResidentNV( GLenum target )
{
    struct glMakeBufferNonResidentNV_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glMakeBufferNonResidentNV, &args ))) WARN( "glMakeBufferNonResidentNV returned %#lx\n", status );
}

static void WINAPI glMakeBufferResidentNV( GLenum target, GLenum access )
{
    struct glMakeBufferResidentNV_params args = { .teb = NtCurrentTeb(), .target = target, .access = access };
    NTSTATUS status;
    TRACE( "target %d, access %d\n", target, access );
    if ((status = UNIX_CALL( glMakeBufferResidentNV, &args ))) WARN( "glMakeBufferResidentNV returned %#lx\n", status );
}

static void WINAPI glMakeImageHandleNonResidentARB( GLuint64 handle )
{
    struct glMakeImageHandleNonResidentARB_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glMakeImageHandleNonResidentARB, &args ))) WARN( "glMakeImageHandleNonResidentARB returned %#lx\n", status );
}

static void WINAPI glMakeImageHandleNonResidentNV( GLuint64 handle )
{
    struct glMakeImageHandleNonResidentNV_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glMakeImageHandleNonResidentNV, &args ))) WARN( "glMakeImageHandleNonResidentNV returned %#lx\n", status );
}

static void WINAPI glMakeImageHandleResidentARB( GLuint64 handle, GLenum access )
{
    struct glMakeImageHandleResidentARB_params args = { .teb = NtCurrentTeb(), .handle = handle, .access = access };
    NTSTATUS status;
    TRACE( "handle %s, access %d\n", wine_dbgstr_longlong(handle), access );
    if ((status = UNIX_CALL( glMakeImageHandleResidentARB, &args ))) WARN( "glMakeImageHandleResidentARB returned %#lx\n", status );
}

static void WINAPI glMakeImageHandleResidentNV( GLuint64 handle, GLenum access )
{
    struct glMakeImageHandleResidentNV_params args = { .teb = NtCurrentTeb(), .handle = handle, .access = access };
    NTSTATUS status;
    TRACE( "handle %s, access %d\n", wine_dbgstr_longlong(handle), access );
    if ((status = UNIX_CALL( glMakeImageHandleResidentNV, &args ))) WARN( "glMakeImageHandleResidentNV returned %#lx\n", status );
}

static void WINAPI glMakeNamedBufferNonResidentNV( GLuint buffer )
{
    struct glMakeNamedBufferNonResidentNV_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glMakeNamedBufferNonResidentNV, &args ))) WARN( "glMakeNamedBufferNonResidentNV returned %#lx\n", status );
}

static void WINAPI glMakeNamedBufferResidentNV( GLuint buffer, GLenum access )
{
    struct glMakeNamedBufferResidentNV_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .access = access };
    NTSTATUS status;
    TRACE( "buffer %d, access %d\n", buffer, access );
    if ((status = UNIX_CALL( glMakeNamedBufferResidentNV, &args ))) WARN( "glMakeNamedBufferResidentNV returned %#lx\n", status );
}

static void WINAPI glMakeTextureHandleNonResidentARB( GLuint64 handle )
{
    struct glMakeTextureHandleNonResidentARB_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glMakeTextureHandleNonResidentARB, &args ))) WARN( "glMakeTextureHandleNonResidentARB returned %#lx\n", status );
}

static void WINAPI glMakeTextureHandleNonResidentNV( GLuint64 handle )
{
    struct glMakeTextureHandleNonResidentNV_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glMakeTextureHandleNonResidentNV, &args ))) WARN( "glMakeTextureHandleNonResidentNV returned %#lx\n", status );
}

static void WINAPI glMakeTextureHandleResidentARB( GLuint64 handle )
{
    struct glMakeTextureHandleResidentARB_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glMakeTextureHandleResidentARB, &args ))) WARN( "glMakeTextureHandleResidentARB returned %#lx\n", status );
}

static void WINAPI glMakeTextureHandleResidentNV( GLuint64 handle )
{
    struct glMakeTextureHandleResidentNV_params args = { .teb = NtCurrentTeb(), .handle = handle };
    NTSTATUS status;
    TRACE( "handle %s\n", wine_dbgstr_longlong(handle) );
    if ((status = UNIX_CALL( glMakeTextureHandleResidentNV, &args ))) WARN( "glMakeTextureHandleResidentNV returned %#lx\n", status );
}

static void WINAPI glMap1xOES( GLenum target, GLfixed u1, GLfixed u2, GLint stride, GLint order, GLfixed points )
{
    struct glMap1xOES_params args = { .teb = NtCurrentTeb(), .target = target, .u1 = u1, .u2 = u2, .stride = stride, .order = order, .points = points };
    NTSTATUS status;
    TRACE( "target %d, u1 %d, u2 %d, stride %d, order %d, points %d\n", target, u1, u2, stride, order, points );
    if ((status = UNIX_CALL( glMap1xOES, &args ))) WARN( "glMap1xOES returned %#lx\n", status );
}

static void WINAPI glMap2xOES( GLenum target, GLfixed u1, GLfixed u2, GLint ustride, GLint uorder, GLfixed v1, GLfixed v2, GLint vstride, GLint vorder, GLfixed points )
{
    struct glMap2xOES_params args = { .teb = NtCurrentTeb(), .target = target, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .points = points };
    NTSTATUS status;
    TRACE( "target %d, u1 %d, u2 %d, ustride %d, uorder %d, v1 %d, v2 %d, vstride %d, vorder %d, points %d\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
    if ((status = UNIX_CALL( glMap2xOES, &args ))) WARN( "glMap2xOES returned %#lx\n", status );
}

static void WINAPI glMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void *points )
{
    struct glMapControlPointsNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .type = type, .ustride = ustride, .vstride = vstride, .uorder = uorder, .vorder = vorder, .packed = packed, .points = points };
    NTSTATUS status;
    TRACE( "target %d, index %d, type %d, ustride %d, vstride %d, uorder %d, vorder %d, packed %d, points %p\n", target, index, type, ustride, vstride, uorder, vorder, packed, points );
    if ((status = UNIX_CALL( glMapControlPointsNV, &args ))) WARN( "glMapControlPointsNV returned %#lx\n", status );
}

static void WINAPI glMapGrid1xOES( GLint n, GLfixed u1, GLfixed u2 )
{
    struct glMapGrid1xOES_params args = { .teb = NtCurrentTeb(), .n = n, .u1 = u1, .u2 = u2 };
    NTSTATUS status;
    TRACE( "n %d, u1 %d, u2 %d\n", n, u1, u2 );
    if ((status = UNIX_CALL( glMapGrid1xOES, &args ))) WARN( "glMapGrid1xOES returned %#lx\n", status );
}

static void WINAPI glMapGrid2xOES( GLint n, GLfixed u1, GLfixed u2, GLfixed v1, GLfixed v2 )
{
    struct glMapGrid2xOES_params args = { .teb = NtCurrentTeb(), .n = n, .u1 = u1, .u2 = u2, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "n %d, u1 %d, u2 %d, v1 %d, v2 %d\n", n, u1, u2, v1, v2 );
    if ((status = UNIX_CALL( glMapGrid2xOES, &args ))) WARN( "glMapGrid2xOES returned %#lx\n", status );
}

static void * WINAPI glMapObjectBufferATI( GLuint buffer )
{
    struct glMapObjectBufferATI_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glMapObjectBufferATI, &args ))) WARN( "glMapObjectBufferATI returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glMapParameterfvNV( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glMapParameterfvNV_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glMapParameterfvNV, &args ))) WARN( "glMapParameterfvNV returned %#lx\n", status );
}

static void WINAPI glMapParameterivNV( GLenum target, GLenum pname, const GLint *params )
{
    struct glMapParameterivNV_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glMapParameterivNV, &args ))) WARN( "glMapParameterivNV returned %#lx\n", status );
}

static void * WINAPI glMapTexture2DINTEL( GLuint texture, GLint level, GLbitfield access, GLint *stride, GLenum *layout )
{
    struct glMapTexture2DINTEL_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .access = access, .stride = stride, .layout = layout };
    NTSTATUS status;
    TRACE( "texture %d, level %d, access %d, stride %p, layout %p\n", texture, level, access, stride, layout );
    if ((status = UNIX_CALL( glMapTexture2DINTEL, &args ))) WARN( "glMapTexture2DINTEL returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glMapVertexAttrib1dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
{
    struct glMapVertexAttrib1dAPPLE_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .u1 = u1, .u2 = u2, .stride = stride, .order = order, .points = points };
    NTSTATUS status;
    TRACE( "index %d, size %d, u1 %f, u2 %f, stride %d, order %d, points %p\n", index, size, u1, u2, stride, order, points );
    if ((status = UNIX_CALL( glMapVertexAttrib1dAPPLE, &args ))) WARN( "glMapVertexAttrib1dAPPLE returned %#lx\n", status );
}

static void WINAPI glMapVertexAttrib1fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
{
    struct glMapVertexAttrib1fAPPLE_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .u1 = u1, .u2 = u2, .stride = stride, .order = order, .points = points };
    NTSTATUS status;
    TRACE( "index %d, size %d, u1 %f, u2 %f, stride %d, order %d, points %p\n", index, size, u1, u2, stride, order, points );
    if ((status = UNIX_CALL( glMapVertexAttrib1fAPPLE, &args ))) WARN( "glMapVertexAttrib1fAPPLE returned %#lx\n", status );
}

static void WINAPI glMapVertexAttrib2dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
{
    struct glMapVertexAttrib2dAPPLE_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .points = points };
    NTSTATUS status;
    TRACE( "index %d, size %d, u1 %f, u2 %f, ustride %d, uorder %d, v1 %f, v2 %f, vstride %d, vorder %d, points %p\n", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
    if ((status = UNIX_CALL( glMapVertexAttrib2dAPPLE, &args ))) WARN( "glMapVertexAttrib2dAPPLE returned %#lx\n", status );
}

static void WINAPI glMapVertexAttrib2fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
{
    struct glMapVertexAttrib2fAPPLE_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .points = points };
    NTSTATUS status;
    TRACE( "index %d, size %d, u1 %f, u2 %f, ustride %d, uorder %d, v1 %f, v2 %f, vstride %d, vorder %d, points %p\n", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
    if ((status = UNIX_CALL( glMapVertexAttrib2fAPPLE, &args ))) WARN( "glMapVertexAttrib2fAPPLE returned %#lx\n", status );
}

static void WINAPI glMaterialxOES( GLenum face, GLenum pname, GLfixed param )
{
    struct glMaterialxOES_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "face %d, pname %d, param %d\n", face, pname, param );
    if ((status = UNIX_CALL( glMaterialxOES, &args ))) WARN( "glMaterialxOES returned %#lx\n", status );
}

static void WINAPI glMaterialxvOES( GLenum face, GLenum pname, const GLfixed *param )
{
    struct glMaterialxvOES_params args = { .teb = NtCurrentTeb(), .face = face, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "face %d, pname %d, param %p\n", face, pname, param );
    if ((status = UNIX_CALL( glMaterialxvOES, &args ))) WARN( "glMaterialxvOES returned %#lx\n", status );
}

static void WINAPI glMatrixFrustumEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
{
    struct glMatrixFrustumEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .left = left, .right = right, .bottom = bottom, .top = top, .zNear = zNear, .zFar = zFar };
    NTSTATUS status;
    TRACE( "mode %d, left %f, right %f, bottom %f, top %f, zNear %f, zFar %f\n", mode, left, right, bottom, top, zNear, zFar );
    if ((status = UNIX_CALL( glMatrixFrustumEXT, &args ))) WARN( "glMatrixFrustumEXT returned %#lx\n", status );
}

static void WINAPI glMatrixIndexPointerARB( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glMatrixIndexPointerARB_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
    if ((status = UNIX_CALL( glMatrixIndexPointerARB, &args ))) WARN( "glMatrixIndexPointerARB returned %#lx\n", status );
}

static void WINAPI glMatrixIndexubvARB( GLint size, const GLubyte *indices )
{
    struct glMatrixIndexubvARB_params args = { .teb = NtCurrentTeb(), .size = size, .indices = indices };
    NTSTATUS status;
    TRACE( "size %d, indices %p\n", size, indices );
    if ((status = UNIX_CALL( glMatrixIndexubvARB, &args ))) WARN( "glMatrixIndexubvARB returned %#lx\n", status );
}

static void WINAPI glMatrixIndexuivARB( GLint size, const GLuint *indices )
{
    struct glMatrixIndexuivARB_params args = { .teb = NtCurrentTeb(), .size = size, .indices = indices };
    NTSTATUS status;
    TRACE( "size %d, indices %p\n", size, indices );
    if ((status = UNIX_CALL( glMatrixIndexuivARB, &args ))) WARN( "glMatrixIndexuivARB returned %#lx\n", status );
}

static void WINAPI glMatrixIndexusvARB( GLint size, const GLushort *indices )
{
    struct glMatrixIndexusvARB_params args = { .teb = NtCurrentTeb(), .size = size, .indices = indices };
    NTSTATUS status;
    TRACE( "size %d, indices %p\n", size, indices );
    if ((status = UNIX_CALL( glMatrixIndexusvARB, &args ))) WARN( "glMatrixIndexusvARB returned %#lx\n", status );
}

static void WINAPI glMatrixLoad3x2fNV( GLenum matrixMode, const GLfloat *m )
{
    struct glMatrixLoad3x2fNV_params args = { .teb = NtCurrentTeb(), .matrixMode = matrixMode, .m = m };
    NTSTATUS status;
    TRACE( "matrixMode %d, m %p\n", matrixMode, m );
    if ((status = UNIX_CALL( glMatrixLoad3x2fNV, &args ))) WARN( "glMatrixLoad3x2fNV returned %#lx\n", status );
}

static void WINAPI glMatrixLoad3x3fNV( GLenum matrixMode, const GLfloat *m )
{
    struct glMatrixLoad3x3fNV_params args = { .teb = NtCurrentTeb(), .matrixMode = matrixMode, .m = m };
    NTSTATUS status;
    TRACE( "matrixMode %d, m %p\n", matrixMode, m );
    if ((status = UNIX_CALL( glMatrixLoad3x3fNV, &args ))) WARN( "glMatrixLoad3x3fNV returned %#lx\n", status );
}

static void WINAPI glMatrixLoadIdentityEXT( GLenum mode )
{
    struct glMatrixLoadIdentityEXT_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glMatrixLoadIdentityEXT, &args ))) WARN( "glMatrixLoadIdentityEXT returned %#lx\n", status );
}

static void WINAPI glMatrixLoadTranspose3x3fNV( GLenum matrixMode, const GLfloat *m )
{
    struct glMatrixLoadTranspose3x3fNV_params args = { .teb = NtCurrentTeb(), .matrixMode = matrixMode, .m = m };
    NTSTATUS status;
    TRACE( "matrixMode %d, m %p\n", matrixMode, m );
    if ((status = UNIX_CALL( glMatrixLoadTranspose3x3fNV, &args ))) WARN( "glMatrixLoadTranspose3x3fNV returned %#lx\n", status );
}

static void WINAPI glMatrixLoadTransposedEXT( GLenum mode, const GLdouble *m )
{
    struct glMatrixLoadTransposedEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .m = m };
    NTSTATUS status;
    TRACE( "mode %d, m %p\n", mode, m );
    if ((status = UNIX_CALL( glMatrixLoadTransposedEXT, &args ))) WARN( "glMatrixLoadTransposedEXT returned %#lx\n", status );
}

static void WINAPI glMatrixLoadTransposefEXT( GLenum mode, const GLfloat *m )
{
    struct glMatrixLoadTransposefEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .m = m };
    NTSTATUS status;
    TRACE( "mode %d, m %p\n", mode, m );
    if ((status = UNIX_CALL( glMatrixLoadTransposefEXT, &args ))) WARN( "glMatrixLoadTransposefEXT returned %#lx\n", status );
}

static void WINAPI glMatrixLoaddEXT( GLenum mode, const GLdouble *m )
{
    struct glMatrixLoaddEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .m = m };
    NTSTATUS status;
    TRACE( "mode %d, m %p\n", mode, m );
    if ((status = UNIX_CALL( glMatrixLoaddEXT, &args ))) WARN( "glMatrixLoaddEXT returned %#lx\n", status );
}

static void WINAPI glMatrixLoadfEXT( GLenum mode, const GLfloat *m )
{
    struct glMatrixLoadfEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .m = m };
    NTSTATUS status;
    TRACE( "mode %d, m %p\n", mode, m );
    if ((status = UNIX_CALL( glMatrixLoadfEXT, &args ))) WARN( "glMatrixLoadfEXT returned %#lx\n", status );
}

static void WINAPI glMatrixMult3x2fNV( GLenum matrixMode, const GLfloat *m )
{
    struct glMatrixMult3x2fNV_params args = { .teb = NtCurrentTeb(), .matrixMode = matrixMode, .m = m };
    NTSTATUS status;
    TRACE( "matrixMode %d, m %p\n", matrixMode, m );
    if ((status = UNIX_CALL( glMatrixMult3x2fNV, &args ))) WARN( "glMatrixMult3x2fNV returned %#lx\n", status );
}

static void WINAPI glMatrixMult3x3fNV( GLenum matrixMode, const GLfloat *m )
{
    struct glMatrixMult3x3fNV_params args = { .teb = NtCurrentTeb(), .matrixMode = matrixMode, .m = m };
    NTSTATUS status;
    TRACE( "matrixMode %d, m %p\n", matrixMode, m );
    if ((status = UNIX_CALL( glMatrixMult3x3fNV, &args ))) WARN( "glMatrixMult3x3fNV returned %#lx\n", status );
}

static void WINAPI glMatrixMultTranspose3x3fNV( GLenum matrixMode, const GLfloat *m )
{
    struct glMatrixMultTranspose3x3fNV_params args = { .teb = NtCurrentTeb(), .matrixMode = matrixMode, .m = m };
    NTSTATUS status;
    TRACE( "matrixMode %d, m %p\n", matrixMode, m );
    if ((status = UNIX_CALL( glMatrixMultTranspose3x3fNV, &args ))) WARN( "glMatrixMultTranspose3x3fNV returned %#lx\n", status );
}

static void WINAPI glMatrixMultTransposedEXT( GLenum mode, const GLdouble *m )
{
    struct glMatrixMultTransposedEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .m = m };
    NTSTATUS status;
    TRACE( "mode %d, m %p\n", mode, m );
    if ((status = UNIX_CALL( glMatrixMultTransposedEXT, &args ))) WARN( "glMatrixMultTransposedEXT returned %#lx\n", status );
}

static void WINAPI glMatrixMultTransposefEXT( GLenum mode, const GLfloat *m )
{
    struct glMatrixMultTransposefEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .m = m };
    NTSTATUS status;
    TRACE( "mode %d, m %p\n", mode, m );
    if ((status = UNIX_CALL( glMatrixMultTransposefEXT, &args ))) WARN( "glMatrixMultTransposefEXT returned %#lx\n", status );
}

static void WINAPI glMatrixMultdEXT( GLenum mode, const GLdouble *m )
{
    struct glMatrixMultdEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .m = m };
    NTSTATUS status;
    TRACE( "mode %d, m %p\n", mode, m );
    if ((status = UNIX_CALL( glMatrixMultdEXT, &args ))) WARN( "glMatrixMultdEXT returned %#lx\n", status );
}

static void WINAPI glMatrixMultfEXT( GLenum mode, const GLfloat *m )
{
    struct glMatrixMultfEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .m = m };
    NTSTATUS status;
    TRACE( "mode %d, m %p\n", mode, m );
    if ((status = UNIX_CALL( glMatrixMultfEXT, &args ))) WARN( "glMatrixMultfEXT returned %#lx\n", status );
}

static void WINAPI glMatrixOrthoEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
{
    struct glMatrixOrthoEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .left = left, .right = right, .bottom = bottom, .top = top, .zNear = zNear, .zFar = zFar };
    NTSTATUS status;
    TRACE( "mode %d, left %f, right %f, bottom %f, top %f, zNear %f, zFar %f\n", mode, left, right, bottom, top, zNear, zFar );
    if ((status = UNIX_CALL( glMatrixOrthoEXT, &args ))) WARN( "glMatrixOrthoEXT returned %#lx\n", status );
}

static void WINAPI glMatrixPopEXT( GLenum mode )
{
    struct glMatrixPopEXT_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glMatrixPopEXT, &args ))) WARN( "glMatrixPopEXT returned %#lx\n", status );
}

static void WINAPI glMatrixPushEXT( GLenum mode )
{
    struct glMatrixPushEXT_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glMatrixPushEXT, &args ))) WARN( "glMatrixPushEXT returned %#lx\n", status );
}

static void WINAPI glMatrixRotatedEXT( GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
{
    struct glMatrixRotatedEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .angle = angle, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "mode %d, angle %f, x %f, y %f, z %f\n", mode, angle, x, y, z );
    if ((status = UNIX_CALL( glMatrixRotatedEXT, &args ))) WARN( "glMatrixRotatedEXT returned %#lx\n", status );
}

static void WINAPI glMatrixRotatefEXT( GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
{
    struct glMatrixRotatefEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .angle = angle, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "mode %d, angle %f, x %f, y %f, z %f\n", mode, angle, x, y, z );
    if ((status = UNIX_CALL( glMatrixRotatefEXT, &args ))) WARN( "glMatrixRotatefEXT returned %#lx\n", status );
}

static void WINAPI glMatrixScaledEXT( GLenum mode, GLdouble x, GLdouble y, GLdouble z )
{
    struct glMatrixScaledEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "mode %d, x %f, y %f, z %f\n", mode, x, y, z );
    if ((status = UNIX_CALL( glMatrixScaledEXT, &args ))) WARN( "glMatrixScaledEXT returned %#lx\n", status );
}

static void WINAPI glMatrixScalefEXT( GLenum mode, GLfloat x, GLfloat y, GLfloat z )
{
    struct glMatrixScalefEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "mode %d, x %f, y %f, z %f\n", mode, x, y, z );
    if ((status = UNIX_CALL( glMatrixScalefEXT, &args ))) WARN( "glMatrixScalefEXT returned %#lx\n", status );
}

static void WINAPI glMatrixTranslatedEXT( GLenum mode, GLdouble x, GLdouble y, GLdouble z )
{
    struct glMatrixTranslatedEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "mode %d, x %f, y %f, z %f\n", mode, x, y, z );
    if ((status = UNIX_CALL( glMatrixTranslatedEXT, &args ))) WARN( "glMatrixTranslatedEXT returned %#lx\n", status );
}

static void WINAPI glMatrixTranslatefEXT( GLenum mode, GLfloat x, GLfloat y, GLfloat z )
{
    struct glMatrixTranslatefEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "mode %d, x %f, y %f, z %f\n", mode, x, y, z );
    if ((status = UNIX_CALL( glMatrixTranslatefEXT, &args ))) WARN( "glMatrixTranslatefEXT returned %#lx\n", status );
}

static void WINAPI glMaxShaderCompilerThreadsARB( GLuint count )
{
    struct glMaxShaderCompilerThreadsARB_params args = { .teb = NtCurrentTeb(), .count = count };
    NTSTATUS status;
    TRACE( "count %d\n", count );
    if ((status = UNIX_CALL( glMaxShaderCompilerThreadsARB, &args ))) WARN( "glMaxShaderCompilerThreadsARB returned %#lx\n", status );
}

static void WINAPI glMaxShaderCompilerThreadsKHR( GLuint count )
{
    struct glMaxShaderCompilerThreadsKHR_params args = { .teb = NtCurrentTeb(), .count = count };
    NTSTATUS status;
    TRACE( "count %d\n", count );
    if ((status = UNIX_CALL( glMaxShaderCompilerThreadsKHR, &args ))) WARN( "glMaxShaderCompilerThreadsKHR returned %#lx\n", status );
}

static void WINAPI glMemoryBarrier( GLbitfield barriers )
{
    struct glMemoryBarrier_params args = { .teb = NtCurrentTeb(), .barriers = barriers };
    NTSTATUS status;
    TRACE( "barriers %d\n", barriers );
    if ((status = UNIX_CALL( glMemoryBarrier, &args ))) WARN( "glMemoryBarrier returned %#lx\n", status );
}

static void WINAPI glMemoryBarrierByRegion( GLbitfield barriers )
{
    struct glMemoryBarrierByRegion_params args = { .teb = NtCurrentTeb(), .barriers = barriers };
    NTSTATUS status;
    TRACE( "barriers %d\n", barriers );
    if ((status = UNIX_CALL( glMemoryBarrierByRegion, &args ))) WARN( "glMemoryBarrierByRegion returned %#lx\n", status );
}

static void WINAPI glMemoryBarrierEXT( GLbitfield barriers )
{
    struct glMemoryBarrierEXT_params args = { .teb = NtCurrentTeb(), .barriers = barriers };
    NTSTATUS status;
    TRACE( "barriers %d\n", barriers );
    if ((status = UNIX_CALL( glMemoryBarrierEXT, &args ))) WARN( "glMemoryBarrierEXT returned %#lx\n", status );
}

static void WINAPI glMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, const GLint *params )
{
    struct glMemoryObjectParameterivEXT_params args = { .teb = NtCurrentTeb(), .memoryObject = memoryObject, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "memoryObject %d, pname %d, params %p\n", memoryObject, pname, params );
    if ((status = UNIX_CALL( glMemoryObjectParameterivEXT, &args ))) WARN( "glMemoryObjectParameterivEXT returned %#lx\n", status );
}

static void WINAPI glMinSampleShading( GLfloat value )
{
    struct glMinSampleShading_params args = { .teb = NtCurrentTeb(), .value = value };
    NTSTATUS status;
    TRACE( "value %f\n", value );
    if ((status = UNIX_CALL( glMinSampleShading, &args ))) WARN( "glMinSampleShading returned %#lx\n", status );
}

static void WINAPI glMinSampleShadingARB( GLfloat value )
{
    struct glMinSampleShadingARB_params args = { .teb = NtCurrentTeb(), .value = value };
    NTSTATUS status;
    TRACE( "value %f\n", value );
    if ((status = UNIX_CALL( glMinSampleShadingARB, &args ))) WARN( "glMinSampleShadingARB returned %#lx\n", status );
}

static void WINAPI glMinmax( GLenum target, GLenum internalformat, GLboolean sink )
{
    struct glMinmax_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .sink = sink };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, sink %d\n", target, internalformat, sink );
    if ((status = UNIX_CALL( glMinmax, &args ))) WARN( "glMinmax returned %#lx\n", status );
}

static void WINAPI glMinmaxEXT( GLenum target, GLenum internalformat, GLboolean sink )
{
    struct glMinmaxEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .sink = sink };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, sink %d\n", target, internalformat, sink );
    if ((status = UNIX_CALL( glMinmaxEXT, &args ))) WARN( "glMinmaxEXT returned %#lx\n", status );
}

static void WINAPI glMultMatrixxOES( const GLfixed *m )
{
    struct glMultMatrixxOES_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glMultMatrixxOES, &args ))) WARN( "glMultMatrixxOES returned %#lx\n", status );
}

static void WINAPI glMultTransposeMatrixd( const GLdouble *m )
{
    struct glMultTransposeMatrixd_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glMultTransposeMatrixd, &args ))) WARN( "glMultTransposeMatrixd returned %#lx\n", status );
}

static void WINAPI glMultTransposeMatrixdARB( const GLdouble *m )
{
    struct glMultTransposeMatrixdARB_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glMultTransposeMatrixdARB, &args ))) WARN( "glMultTransposeMatrixdARB returned %#lx\n", status );
}

static void WINAPI glMultTransposeMatrixf( const GLfloat *m )
{
    struct glMultTransposeMatrixf_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glMultTransposeMatrixf, &args ))) WARN( "glMultTransposeMatrixf returned %#lx\n", status );
}

static void WINAPI glMultTransposeMatrixfARB( const GLfloat *m )
{
    struct glMultTransposeMatrixfARB_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glMultTransposeMatrixfARB, &args ))) WARN( "glMultTransposeMatrixfARB returned %#lx\n", status );
}

static void WINAPI glMultTransposeMatrixxOES( const GLfixed *m )
{
    struct glMultTransposeMatrixxOES_params args = { .teb = NtCurrentTeb(), .m = m };
    NTSTATUS status;
    TRACE( "m %p\n", m );
    if ((status = UNIX_CALL( glMultTransposeMatrixxOES, &args ))) WARN( "glMultTransposeMatrixxOES returned %#lx\n", status );
}

static void WINAPI glMultiDrawArrays( GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount )
{
    struct glMultiDrawArrays_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count, .drawcount = drawcount };
    NTSTATUS status;
    TRACE( "mode %d, first %p, count %p, drawcount %d\n", mode, first, count, drawcount );
    if ((status = UNIX_CALL( glMultiDrawArrays, &args ))) WARN( "glMultiDrawArrays returned %#lx\n", status );
}

static void WINAPI glMultiDrawArraysEXT( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount )
{
    struct glMultiDrawArraysEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count, .primcount = primcount };
    NTSTATUS status;
    TRACE( "mode %d, first %p, count %p, primcount %d\n", mode, first, count, primcount );
    if ((status = UNIX_CALL( glMultiDrawArraysEXT, &args ))) WARN( "glMultiDrawArraysEXT returned %#lx\n", status );
}

static void WINAPI glMultiDrawArraysIndirect( GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride )
{
    struct glMultiDrawArraysIndirect_params args = { .teb = NtCurrentTeb(), .mode = mode, .indirect = indirect, .drawcount = drawcount, .stride = stride };
    NTSTATUS status;
    TRACE( "mode %d, indirect %p, drawcount %d, stride %d\n", mode, indirect, drawcount, stride );
    if ((status = UNIX_CALL( glMultiDrawArraysIndirect, &args ))) WARN( "glMultiDrawArraysIndirect returned %#lx\n", status );
}

static void WINAPI glMultiDrawArraysIndirectAMD( GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride )
{
    struct glMultiDrawArraysIndirectAMD_params args = { .teb = NtCurrentTeb(), .mode = mode, .indirect = indirect, .primcount = primcount, .stride = stride };
    NTSTATUS status;
    TRACE( "mode %d, indirect %p, primcount %d, stride %d\n", mode, indirect, primcount, stride );
    if ((status = UNIX_CALL( glMultiDrawArraysIndirectAMD, &args ))) WARN( "glMultiDrawArraysIndirectAMD returned %#lx\n", status );
}

static void WINAPI glMultiDrawArraysIndirectBindlessCountNV( GLenum mode, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount )
{
    struct glMultiDrawArraysIndirectBindlessCountNV_params args = { .teb = NtCurrentTeb(), .mode = mode, .indirect = indirect, .drawCount = drawCount, .maxDrawCount = maxDrawCount, .stride = stride, .vertexBufferCount = vertexBufferCount };
    NTSTATUS status;
    TRACE( "mode %d, indirect %p, drawCount %d, maxDrawCount %d, stride %d, vertexBufferCount %d\n", mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount );
    if ((status = UNIX_CALL( glMultiDrawArraysIndirectBindlessCountNV, &args ))) WARN( "glMultiDrawArraysIndirectBindlessCountNV returned %#lx\n", status );
}

static void WINAPI glMultiDrawArraysIndirectBindlessNV( GLenum mode, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount )
{
    struct glMultiDrawArraysIndirectBindlessNV_params args = { .teb = NtCurrentTeb(), .mode = mode, .indirect = indirect, .drawCount = drawCount, .stride = stride, .vertexBufferCount = vertexBufferCount };
    NTSTATUS status;
    TRACE( "mode %d, indirect %p, drawCount %d, stride %d, vertexBufferCount %d\n", mode, indirect, drawCount, stride, vertexBufferCount );
    if ((status = UNIX_CALL( glMultiDrawArraysIndirectBindlessNV, &args ))) WARN( "glMultiDrawArraysIndirectBindlessNV returned %#lx\n", status );
}

static void WINAPI glMultiDrawArraysIndirectCount( GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
{
    struct glMultiDrawArraysIndirectCount_params args = { .teb = NtCurrentTeb(), .mode = mode, .indirect = indirect, .drawcount = drawcount, .maxdrawcount = maxdrawcount, .stride = stride };
    NTSTATUS status;
    TRACE( "mode %d, indirect %p, drawcount %Id, maxdrawcount %d, stride %d\n", mode, indirect, drawcount, maxdrawcount, stride );
    if ((status = UNIX_CALL( glMultiDrawArraysIndirectCount, &args ))) WARN( "glMultiDrawArraysIndirectCount returned %#lx\n", status );
}

static void WINAPI glMultiDrawArraysIndirectCountARB( GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
{
    struct glMultiDrawArraysIndirectCountARB_params args = { .teb = NtCurrentTeb(), .mode = mode, .indirect = indirect, .drawcount = drawcount, .maxdrawcount = maxdrawcount, .stride = stride };
    NTSTATUS status;
    TRACE( "mode %d, indirect %p, drawcount %Id, maxdrawcount %d, stride %d\n", mode, indirect, drawcount, maxdrawcount, stride );
    if ((status = UNIX_CALL( glMultiDrawArraysIndirectCountARB, &args ))) WARN( "glMultiDrawArraysIndirectCountARB returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementArrayAPPLE( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount )
{
    struct glMultiDrawElementArrayAPPLE_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count, .primcount = primcount };
    NTSTATUS status;
    TRACE( "mode %d, first %p, count %p, primcount %d\n", mode, first, count, primcount );
    if ((status = UNIX_CALL( glMultiDrawElementArrayAPPLE, &args ))) WARN( "glMultiDrawElementArrayAPPLE returned %#lx\n", status );
}

static void WINAPI glMultiDrawElements( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount )
{
    struct glMultiDrawElements_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .drawcount = drawcount };
    NTSTATUS status;
    TRACE( "mode %d, count %p, type %d, indices %p, drawcount %d\n", mode, count, type, indices, drawcount );
    if ((status = UNIX_CALL( glMultiDrawElements, &args ))) WARN( "glMultiDrawElements returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementsBaseVertex( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex )
{
    struct glMultiDrawElementsBaseVertex_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .drawcount = drawcount, .basevertex = basevertex };
    NTSTATUS status;
    TRACE( "mode %d, count %p, type %d, indices %p, drawcount %d, basevertex %p\n", mode, count, type, indices, drawcount, basevertex );
    if ((status = UNIX_CALL( glMultiDrawElementsBaseVertex, &args ))) WARN( "glMultiDrawElementsBaseVertex returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount )
{
    struct glMultiDrawElementsEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .primcount = primcount };
    NTSTATUS status;
    TRACE( "mode %d, count %p, type %d, indices %p, primcount %d\n", mode, count, type, indices, primcount );
    if ((status = UNIX_CALL( glMultiDrawElementsEXT, &args ))) WARN( "glMultiDrawElementsEXT returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementsIndirect( GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride )
{
    struct glMultiDrawElementsIndirect_params args = { .teb = NtCurrentTeb(), .mode = mode, .type = type, .indirect = indirect, .drawcount = drawcount, .stride = stride };
    NTSTATUS status;
    TRACE( "mode %d, type %d, indirect %p, drawcount %d, stride %d\n", mode, type, indirect, drawcount, stride );
    if ((status = UNIX_CALL( glMultiDrawElementsIndirect, &args ))) WARN( "glMultiDrawElementsIndirect returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementsIndirectAMD( GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride )
{
    struct glMultiDrawElementsIndirectAMD_params args = { .teb = NtCurrentTeb(), .mode = mode, .type = type, .indirect = indirect, .primcount = primcount, .stride = stride };
    NTSTATUS status;
    TRACE( "mode %d, type %d, indirect %p, primcount %d, stride %d\n", mode, type, indirect, primcount, stride );
    if ((status = UNIX_CALL( glMultiDrawElementsIndirectAMD, &args ))) WARN( "glMultiDrawElementsIndirectAMD returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementsIndirectBindlessCountNV( GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount )
{
    struct glMultiDrawElementsIndirectBindlessCountNV_params args = { .teb = NtCurrentTeb(), .mode = mode, .type = type, .indirect = indirect, .drawCount = drawCount, .maxDrawCount = maxDrawCount, .stride = stride, .vertexBufferCount = vertexBufferCount };
    NTSTATUS status;
    TRACE( "mode %d, type %d, indirect %p, drawCount %d, maxDrawCount %d, stride %d, vertexBufferCount %d\n", mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount );
    if ((status = UNIX_CALL( glMultiDrawElementsIndirectBindlessCountNV, &args ))) WARN( "glMultiDrawElementsIndirectBindlessCountNV returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementsIndirectBindlessNV( GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount )
{
    struct glMultiDrawElementsIndirectBindlessNV_params args = { .teb = NtCurrentTeb(), .mode = mode, .type = type, .indirect = indirect, .drawCount = drawCount, .stride = stride, .vertexBufferCount = vertexBufferCount };
    NTSTATUS status;
    TRACE( "mode %d, type %d, indirect %p, drawCount %d, stride %d, vertexBufferCount %d\n", mode, type, indirect, drawCount, stride, vertexBufferCount );
    if ((status = UNIX_CALL( glMultiDrawElementsIndirectBindlessNV, &args ))) WARN( "glMultiDrawElementsIndirectBindlessNV returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementsIndirectCount( GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
{
    struct glMultiDrawElementsIndirectCount_params args = { .teb = NtCurrentTeb(), .mode = mode, .type = type, .indirect = indirect, .drawcount = drawcount, .maxdrawcount = maxdrawcount, .stride = stride };
    NTSTATUS status;
    TRACE( "mode %d, type %d, indirect %p, drawcount %Id, maxdrawcount %d, stride %d\n", mode, type, indirect, drawcount, maxdrawcount, stride );
    if ((status = UNIX_CALL( glMultiDrawElementsIndirectCount, &args ))) WARN( "glMultiDrawElementsIndirectCount returned %#lx\n", status );
}

static void WINAPI glMultiDrawElementsIndirectCountARB( GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
{
    struct glMultiDrawElementsIndirectCountARB_params args = { .teb = NtCurrentTeb(), .mode = mode, .type = type, .indirect = indirect, .drawcount = drawcount, .maxdrawcount = maxdrawcount, .stride = stride };
    NTSTATUS status;
    TRACE( "mode %d, type %d, indirect %p, drawcount %Id, maxdrawcount %d, stride %d\n", mode, type, indirect, drawcount, maxdrawcount, stride );
    if ((status = UNIX_CALL( glMultiDrawElementsIndirectCountARB, &args ))) WARN( "glMultiDrawElementsIndirectCountARB returned %#lx\n", status );
}

static void WINAPI glMultiDrawMeshTasksIndirectCountNV( GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
{
    struct glMultiDrawMeshTasksIndirectCountNV_params args = { .teb = NtCurrentTeb(), .indirect = indirect, .drawcount = drawcount, .maxdrawcount = maxdrawcount, .stride = stride };
    NTSTATUS status;
    TRACE( "indirect %Id, drawcount %Id, maxdrawcount %d, stride %d\n", indirect, drawcount, maxdrawcount, stride );
    if ((status = UNIX_CALL( glMultiDrawMeshTasksIndirectCountNV, &args ))) WARN( "glMultiDrawMeshTasksIndirectCountNV returned %#lx\n", status );
}

static void WINAPI glMultiDrawMeshTasksIndirectNV( GLintptr indirect, GLsizei drawcount, GLsizei stride )
{
    struct glMultiDrawMeshTasksIndirectNV_params args = { .teb = NtCurrentTeb(), .indirect = indirect, .drawcount = drawcount, .stride = stride };
    NTSTATUS status;
    TRACE( "indirect %Id, drawcount %d, stride %d\n", indirect, drawcount, stride );
    if ((status = UNIX_CALL( glMultiDrawMeshTasksIndirectNV, &args ))) WARN( "glMultiDrawMeshTasksIndirectNV returned %#lx\n", status );
}

static void WINAPI glMultiDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount )
{
    struct glMultiDrawRangeElementArrayAPPLE_params args = { .teb = NtCurrentTeb(), .mode = mode, .start = start, .end = end, .first = first, .count = count, .primcount = primcount };
    NTSTATUS status;
    TRACE( "mode %d, start %d, end %d, first %p, count %p, primcount %d\n", mode, start, end, first, count, primcount );
    if ((status = UNIX_CALL( glMultiDrawRangeElementArrayAPPLE, &args ))) WARN( "glMultiDrawRangeElementArrayAPPLE returned %#lx\n", status );
}

static void WINAPI glMultiModeDrawArraysIBM( const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride )
{
    struct glMultiModeDrawArraysIBM_params args = { .teb = NtCurrentTeb(), .mode = mode, .first = first, .count = count, .primcount = primcount, .modestride = modestride };
    NTSTATUS status;
    TRACE( "mode %p, first %p, count %p, primcount %d, modestride %d\n", mode, first, count, primcount, modestride );
    if ((status = UNIX_CALL( glMultiModeDrawArraysIBM, &args ))) WARN( "glMultiModeDrawArraysIBM returned %#lx\n", status );
}

static void WINAPI glMultiModeDrawElementsIBM( const GLenum *mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount, GLint modestride )
{
    struct glMultiModeDrawElementsIBM_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .type = type, .indices = indices, .primcount = primcount, .modestride = modestride };
    NTSTATUS status;
    TRACE( "mode %p, count %p, type %d, indices %p, primcount %d, modestride %d\n", mode, count, type, indices, primcount, modestride );
    if ((status = UNIX_CALL( glMultiModeDrawElementsIBM, &args ))) WARN( "glMultiModeDrawElementsIBM returned %#lx\n", status );
}

static void WINAPI glMultiTexBufferEXT( GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer )
{
    struct glMultiTexBufferEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .internalformat = internalformat, .buffer = buffer };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, internalformat %d, buffer %d\n", texunit, target, internalformat, buffer );
    if ((status = UNIX_CALL( glMultiTexBufferEXT, &args ))) WARN( "glMultiTexBufferEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1bOES( GLenum texture, GLbyte s )
{
    struct glMultiTexCoord1bOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .s = s };
    NTSTATUS status;
    TRACE( "texture %d, s %d\n", texture, s );
    if ((status = UNIX_CALL( glMultiTexCoord1bOES, &args ))) WARN( "glMultiTexCoord1bOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1bvOES( GLenum texture, const GLbyte *coords )
{
    struct glMultiTexCoord1bvOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, coords %p\n", texture, coords );
    if ((status = UNIX_CALL( glMultiTexCoord1bvOES, &args ))) WARN( "glMultiTexCoord1bvOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1d( GLenum target, GLdouble s )
{
    struct glMultiTexCoord1d_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %f\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1d, &args ))) WARN( "glMultiTexCoord1d returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1dARB( GLenum target, GLdouble s )
{
    struct glMultiTexCoord1dARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %f\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1dARB, &args ))) WARN( "glMultiTexCoord1dARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1dSGIS( GLenum target, GLdouble s )
{
    struct glMultiTexCoord1dSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %f\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1dSGIS, &args ))) WARN( "glMultiTexCoord1dSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1dv( GLenum target, const GLdouble *v )
{
    struct glMultiTexCoord1dv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1dv, &args ))) WARN( "glMultiTexCoord1dv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1dvARB( GLenum target, const GLdouble *v )
{
    struct glMultiTexCoord1dvARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1dvARB, &args ))) WARN( "glMultiTexCoord1dvARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1dvSGIS( GLenum target, GLdouble * v )
{
    struct glMultiTexCoord1dvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1dvSGIS, &args ))) WARN( "glMultiTexCoord1dvSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1f( GLenum target, GLfloat s )
{
    struct glMultiTexCoord1f_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %f\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1f, &args ))) WARN( "glMultiTexCoord1f returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1fARB( GLenum target, GLfloat s )
{
    struct glMultiTexCoord1fARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %f\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1fARB, &args ))) WARN( "glMultiTexCoord1fARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1fSGIS( GLenum target, GLfloat s )
{
    struct glMultiTexCoord1fSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %f\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1fSGIS, &args ))) WARN( "glMultiTexCoord1fSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1fv( GLenum target, const GLfloat *v )
{
    struct glMultiTexCoord1fv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1fv, &args ))) WARN( "glMultiTexCoord1fv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1fvARB( GLenum target, const GLfloat *v )
{
    struct glMultiTexCoord1fvARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1fvARB, &args ))) WARN( "glMultiTexCoord1fvARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1fvSGIS( GLenum target, const GLfloat * v )
{
    struct glMultiTexCoord1fvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1fvSGIS, &args ))) WARN( "glMultiTexCoord1fvSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1hNV( GLenum target, GLhalfNV s )
{
    struct glMultiTexCoord1hNV_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %d\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1hNV, &args ))) WARN( "glMultiTexCoord1hNV returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1hvNV( GLenum target, const GLhalfNV *v )
{
    struct glMultiTexCoord1hvNV_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1hvNV, &args ))) WARN( "glMultiTexCoord1hvNV returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1i( GLenum target, GLint s )
{
    struct glMultiTexCoord1i_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %d\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1i, &args ))) WARN( "glMultiTexCoord1i returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1iARB( GLenum target, GLint s )
{
    struct glMultiTexCoord1iARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %d\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1iARB, &args ))) WARN( "glMultiTexCoord1iARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1iSGIS( GLenum target, GLint s )
{
    struct glMultiTexCoord1iSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %d\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1iSGIS, &args ))) WARN( "glMultiTexCoord1iSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1iv( GLenum target, const GLint *v )
{
    struct glMultiTexCoord1iv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1iv, &args ))) WARN( "glMultiTexCoord1iv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1ivARB( GLenum target, const GLint *v )
{
    struct glMultiTexCoord1ivARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1ivARB, &args ))) WARN( "glMultiTexCoord1ivARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1ivSGIS( GLenum target, GLint * v )
{
    struct glMultiTexCoord1ivSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1ivSGIS, &args ))) WARN( "glMultiTexCoord1ivSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1s( GLenum target, GLshort s )
{
    struct glMultiTexCoord1s_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %d\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1s, &args ))) WARN( "glMultiTexCoord1s returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1sARB( GLenum target, GLshort s )
{
    struct glMultiTexCoord1sARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %d\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1sARB, &args ))) WARN( "glMultiTexCoord1sARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1sSGIS( GLenum target, GLshort s )
{
    struct glMultiTexCoord1sSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s };
    NTSTATUS status;
    TRACE( "target %d, s %d\n", target, s );
    if ((status = UNIX_CALL( glMultiTexCoord1sSGIS, &args ))) WARN( "glMultiTexCoord1sSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1sv( GLenum target, const GLshort *v )
{
    struct glMultiTexCoord1sv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1sv, &args ))) WARN( "glMultiTexCoord1sv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1svARB( GLenum target, const GLshort *v )
{
    struct glMultiTexCoord1svARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1svARB, &args ))) WARN( "glMultiTexCoord1svARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1svSGIS( GLenum target, GLshort * v )
{
    struct glMultiTexCoord1svSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord1svSGIS, &args ))) WARN( "glMultiTexCoord1svSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1xOES( GLenum texture, GLfixed s )
{
    struct glMultiTexCoord1xOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .s = s };
    NTSTATUS status;
    TRACE( "texture %d, s %d\n", texture, s );
    if ((status = UNIX_CALL( glMultiTexCoord1xOES, &args ))) WARN( "glMultiTexCoord1xOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord1xvOES( GLenum texture, const GLfixed *coords )
{
    struct glMultiTexCoord1xvOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, coords %p\n", texture, coords );
    if ((status = UNIX_CALL( glMultiTexCoord1xvOES, &args ))) WARN( "glMultiTexCoord1xvOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2bOES( GLenum texture, GLbyte s, GLbyte t )
{
    struct glMultiTexCoord2bOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "texture %d, s %d, t %d\n", texture, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2bOES, &args ))) WARN( "glMultiTexCoord2bOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2bvOES( GLenum texture, const GLbyte *coords )
{
    struct glMultiTexCoord2bvOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, coords %p\n", texture, coords );
    if ((status = UNIX_CALL( glMultiTexCoord2bvOES, &args ))) WARN( "glMultiTexCoord2bvOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t )
{
    struct glMultiTexCoord2d_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2d, &args ))) WARN( "glMultiTexCoord2d returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t )
{
    struct glMultiTexCoord2dARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2dARB, &args ))) WARN( "glMultiTexCoord2dARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2dSGIS( GLenum target, GLdouble s, GLdouble t )
{
    struct glMultiTexCoord2dSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2dSGIS, &args ))) WARN( "glMultiTexCoord2dSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2dv( GLenum target, const GLdouble *v )
{
    struct glMultiTexCoord2dv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2dv, &args ))) WARN( "glMultiTexCoord2dv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2dvARB( GLenum target, const GLdouble *v )
{
    struct glMultiTexCoord2dvARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2dvARB, &args ))) WARN( "glMultiTexCoord2dvARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2dvSGIS( GLenum target, GLdouble * v )
{
    struct glMultiTexCoord2dvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2dvSGIS, &args ))) WARN( "glMultiTexCoord2dvSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t )
{
    struct glMultiTexCoord2f_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2f, &args ))) WARN( "glMultiTexCoord2f returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
{
    struct glMultiTexCoord2fARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2fARB, &args ))) WARN( "glMultiTexCoord2fARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t )
{
    struct glMultiTexCoord2fSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2fSGIS, &args ))) WARN( "glMultiTexCoord2fSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2fv( GLenum target, const GLfloat *v )
{
    struct glMultiTexCoord2fv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2fv, &args ))) WARN( "glMultiTexCoord2fv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2fvARB( GLenum target, const GLfloat *v )
{
    struct glMultiTexCoord2fvARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2fvARB, &args ))) WARN( "glMultiTexCoord2fvARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2fvSGIS( GLenum target, GLfloat * v )
{
    struct glMultiTexCoord2fvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2fvSGIS, &args ))) WARN( "glMultiTexCoord2fvSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2hNV( GLenum target, GLhalfNV s, GLhalfNV t )
{
    struct glMultiTexCoord2hNV_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2hNV, &args ))) WARN( "glMultiTexCoord2hNV returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2hvNV( GLenum target, const GLhalfNV *v )
{
    struct glMultiTexCoord2hvNV_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2hvNV, &args ))) WARN( "glMultiTexCoord2hvNV returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2i( GLenum target, GLint s, GLint t )
{
    struct glMultiTexCoord2i_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2i, &args ))) WARN( "glMultiTexCoord2i returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2iARB( GLenum target, GLint s, GLint t )
{
    struct glMultiTexCoord2iARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2iARB, &args ))) WARN( "glMultiTexCoord2iARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2iSGIS( GLenum target, GLint s, GLint t )
{
    struct glMultiTexCoord2iSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2iSGIS, &args ))) WARN( "glMultiTexCoord2iSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2iv( GLenum target, const GLint *v )
{
    struct glMultiTexCoord2iv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2iv, &args ))) WARN( "glMultiTexCoord2iv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2ivARB( GLenum target, const GLint *v )
{
    struct glMultiTexCoord2ivARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2ivARB, &args ))) WARN( "glMultiTexCoord2ivARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2ivSGIS( GLenum target, GLint * v )
{
    struct glMultiTexCoord2ivSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2ivSGIS, &args ))) WARN( "glMultiTexCoord2ivSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2s( GLenum target, GLshort s, GLshort t )
{
    struct glMultiTexCoord2s_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2s, &args ))) WARN( "glMultiTexCoord2s returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t )
{
    struct glMultiTexCoord2sARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2sARB, &args ))) WARN( "glMultiTexCoord2sARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2sSGIS( GLenum target, GLshort s, GLshort t )
{
    struct glMultiTexCoord2sSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d\n", target, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2sSGIS, &args ))) WARN( "glMultiTexCoord2sSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2sv( GLenum target, const GLshort *v )
{
    struct glMultiTexCoord2sv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2sv, &args ))) WARN( "glMultiTexCoord2sv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2svARB( GLenum target, const GLshort *v )
{
    struct glMultiTexCoord2svARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2svARB, &args ))) WARN( "glMultiTexCoord2svARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2svSGIS( GLenum target, GLshort * v )
{
    struct glMultiTexCoord2svSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord2svSGIS, &args ))) WARN( "glMultiTexCoord2svSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2xOES( GLenum texture, GLfixed s, GLfixed t )
{
    struct glMultiTexCoord2xOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .s = s, .t = t };
    NTSTATUS status;
    TRACE( "texture %d, s %d, t %d\n", texture, s, t );
    if ((status = UNIX_CALL( glMultiTexCoord2xOES, &args ))) WARN( "glMultiTexCoord2xOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord2xvOES( GLenum texture, const GLfixed *coords )
{
    struct glMultiTexCoord2xvOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, coords %p\n", texture, coords );
    if ((status = UNIX_CALL( glMultiTexCoord2xvOES, &args ))) WARN( "glMultiTexCoord2xvOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3bOES( GLenum texture, GLbyte s, GLbyte t, GLbyte r )
{
    struct glMultiTexCoord3bOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "texture %d, s %d, t %d, r %d\n", texture, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3bOES, &args ))) WARN( "glMultiTexCoord3bOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3bvOES( GLenum texture, const GLbyte *coords )
{
    struct glMultiTexCoord3bvOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, coords %p\n", texture, coords );
    if ((status = UNIX_CALL( glMultiTexCoord3bvOES, &args ))) WARN( "glMultiTexCoord3bvOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r )
{
    struct glMultiTexCoord3d_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3d, &args ))) WARN( "glMultiTexCoord3d returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r )
{
    struct glMultiTexCoord3dARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3dARB, &args ))) WARN( "glMultiTexCoord3dARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r )
{
    struct glMultiTexCoord3dSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3dSGIS, &args ))) WARN( "glMultiTexCoord3dSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3dv( GLenum target, const GLdouble *v )
{
    struct glMultiTexCoord3dv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3dv, &args ))) WARN( "glMultiTexCoord3dv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3dvARB( GLenum target, const GLdouble *v )
{
    struct glMultiTexCoord3dvARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3dvARB, &args ))) WARN( "glMultiTexCoord3dvARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3dvSGIS( GLenum target, GLdouble * v )
{
    struct glMultiTexCoord3dvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3dvSGIS, &args ))) WARN( "glMultiTexCoord3dvSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r )
{
    struct glMultiTexCoord3f_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3f, &args ))) WARN( "glMultiTexCoord3f returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r )
{
    struct glMultiTexCoord3fARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3fARB, &args ))) WARN( "glMultiTexCoord3fARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r )
{
    struct glMultiTexCoord3fSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3fSGIS, &args ))) WARN( "glMultiTexCoord3fSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3fv( GLenum target, const GLfloat *v )
{
    struct glMultiTexCoord3fv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3fv, &args ))) WARN( "glMultiTexCoord3fv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3fvARB( GLenum target, const GLfloat *v )
{
    struct glMultiTexCoord3fvARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3fvARB, &args ))) WARN( "glMultiTexCoord3fvARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3fvSGIS( GLenum target, GLfloat * v )
{
    struct glMultiTexCoord3fvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3fvSGIS, &args ))) WARN( "glMultiTexCoord3fvSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3hNV( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r )
{
    struct glMultiTexCoord3hNV_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3hNV, &args ))) WARN( "glMultiTexCoord3hNV returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3hvNV( GLenum target, const GLhalfNV *v )
{
    struct glMultiTexCoord3hvNV_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3hvNV, &args ))) WARN( "glMultiTexCoord3hvNV returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r )
{
    struct glMultiTexCoord3i_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3i, &args ))) WARN( "glMultiTexCoord3i returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r )
{
    struct glMultiTexCoord3iARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3iARB, &args ))) WARN( "glMultiTexCoord3iARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3iSGIS( GLenum target, GLint s, GLint t, GLint r )
{
    struct glMultiTexCoord3iSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3iSGIS, &args ))) WARN( "glMultiTexCoord3iSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3iv( GLenum target, const GLint *v )
{
    struct glMultiTexCoord3iv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3iv, &args ))) WARN( "glMultiTexCoord3iv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3ivARB( GLenum target, const GLint *v )
{
    struct glMultiTexCoord3ivARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3ivARB, &args ))) WARN( "glMultiTexCoord3ivARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3ivSGIS( GLenum target, GLint * v )
{
    struct glMultiTexCoord3ivSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3ivSGIS, &args ))) WARN( "glMultiTexCoord3ivSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r )
{
    struct glMultiTexCoord3s_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3s, &args ))) WARN( "glMultiTexCoord3s returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r )
{
    struct glMultiTexCoord3sARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3sARB, &args ))) WARN( "glMultiTexCoord3sARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3sSGIS( GLenum target, GLshort s, GLshort t, GLshort r )
{
    struct glMultiTexCoord3sSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d\n", target, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3sSGIS, &args ))) WARN( "glMultiTexCoord3sSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3sv( GLenum target, const GLshort *v )
{
    struct glMultiTexCoord3sv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3sv, &args ))) WARN( "glMultiTexCoord3sv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3svARB( GLenum target, const GLshort *v )
{
    struct glMultiTexCoord3svARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3svARB, &args ))) WARN( "glMultiTexCoord3svARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3svSGIS( GLenum target, GLshort * v )
{
    struct glMultiTexCoord3svSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord3svSGIS, &args ))) WARN( "glMultiTexCoord3svSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3xOES( GLenum texture, GLfixed s, GLfixed t, GLfixed r )
{
    struct glMultiTexCoord3xOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "texture %d, s %d, t %d, r %d\n", texture, s, t, r );
    if ((status = UNIX_CALL( glMultiTexCoord3xOES, &args ))) WARN( "glMultiTexCoord3xOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord3xvOES( GLenum texture, const GLfixed *coords )
{
    struct glMultiTexCoord3xvOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, coords %p\n", texture, coords );
    if ((status = UNIX_CALL( glMultiTexCoord3xvOES, &args ))) WARN( "glMultiTexCoord3xvOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4bOES( GLenum texture, GLbyte s, GLbyte t, GLbyte r, GLbyte q )
{
    struct glMultiTexCoord4bOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "texture %d, s %d, t %d, r %d, q %d\n", texture, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4bOES, &args ))) WARN( "glMultiTexCoord4bOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4bvOES( GLenum texture, const GLbyte *coords )
{
    struct glMultiTexCoord4bvOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, coords %p\n", texture, coords );
    if ((status = UNIX_CALL( glMultiTexCoord4bvOES, &args ))) WARN( "glMultiTexCoord4bvOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
{
    struct glMultiTexCoord4d_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f, q %f\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4d, &args ))) WARN( "glMultiTexCoord4d returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
{
    struct glMultiTexCoord4dARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f, q %f\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4dARB, &args ))) WARN( "glMultiTexCoord4dARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
{
    struct glMultiTexCoord4dSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f, q %f\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4dSGIS, &args ))) WARN( "glMultiTexCoord4dSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4dv( GLenum target, const GLdouble *v )
{
    struct glMultiTexCoord4dv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4dv, &args ))) WARN( "glMultiTexCoord4dv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4dvARB( GLenum target, const GLdouble *v )
{
    struct glMultiTexCoord4dvARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4dvARB, &args ))) WARN( "glMultiTexCoord4dvARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4dvSGIS( GLenum target, GLdouble * v )
{
    struct glMultiTexCoord4dvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4dvSGIS, &args ))) WARN( "glMultiTexCoord4dvSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
{
    struct glMultiTexCoord4f_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f, q %f\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4f, &args ))) WARN( "glMultiTexCoord4f returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
{
    struct glMultiTexCoord4fARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f, q %f\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4fARB, &args ))) WARN( "glMultiTexCoord4fARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
{
    struct glMultiTexCoord4fSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %f, t %f, r %f, q %f\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4fSGIS, &args ))) WARN( "glMultiTexCoord4fSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4fv( GLenum target, const GLfloat *v )
{
    struct glMultiTexCoord4fv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4fv, &args ))) WARN( "glMultiTexCoord4fv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4fvARB( GLenum target, const GLfloat *v )
{
    struct glMultiTexCoord4fvARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4fvARB, &args ))) WARN( "glMultiTexCoord4fvARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4fvSGIS( GLenum target, GLfloat * v )
{
    struct glMultiTexCoord4fvSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4fvSGIS, &args ))) WARN( "glMultiTexCoord4fvSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4hNV( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q )
{
    struct glMultiTexCoord4hNV_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d, q %d\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4hNV, &args ))) WARN( "glMultiTexCoord4hNV returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4hvNV( GLenum target, const GLhalfNV *v )
{
    struct glMultiTexCoord4hvNV_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4hvNV, &args ))) WARN( "glMultiTexCoord4hvNV returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q )
{
    struct glMultiTexCoord4i_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d, q %d\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4i, &args ))) WARN( "glMultiTexCoord4i returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q )
{
    struct glMultiTexCoord4iARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d, q %d\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4iARB, &args ))) WARN( "glMultiTexCoord4iARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4iSGIS( GLenum target, GLint s, GLint t, GLint r, GLint q )
{
    struct glMultiTexCoord4iSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d, q %d\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4iSGIS, &args ))) WARN( "glMultiTexCoord4iSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4iv( GLenum target, const GLint *v )
{
    struct glMultiTexCoord4iv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4iv, &args ))) WARN( "glMultiTexCoord4iv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4ivARB( GLenum target, const GLint *v )
{
    struct glMultiTexCoord4ivARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4ivARB, &args ))) WARN( "glMultiTexCoord4ivARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4ivSGIS( GLenum target, GLint * v )
{
    struct glMultiTexCoord4ivSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4ivSGIS, &args ))) WARN( "glMultiTexCoord4ivSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
{
    struct glMultiTexCoord4s_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d, q %d\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4s, &args ))) WARN( "glMultiTexCoord4s returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
{
    struct glMultiTexCoord4sARB_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d, q %d\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4sARB, &args ))) WARN( "glMultiTexCoord4sARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4sSGIS( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
{
    struct glMultiTexCoord4sSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "target %d, s %d, t %d, r %d, q %d\n", target, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4sSGIS, &args ))) WARN( "glMultiTexCoord4sSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4sv( GLenum target, const GLshort *v )
{
    struct glMultiTexCoord4sv_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4sv, &args ))) WARN( "glMultiTexCoord4sv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4svARB( GLenum target, const GLshort *v )
{
    struct glMultiTexCoord4svARB_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4svARB, &args ))) WARN( "glMultiTexCoord4svARB returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4svSGIS( GLenum target, GLshort * v )
{
    struct glMultiTexCoord4svSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .v = v };
    NTSTATUS status;
    TRACE( "target %d, v %p\n", target, v );
    if ((status = UNIX_CALL( glMultiTexCoord4svSGIS, &args ))) WARN( "glMultiTexCoord4svSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4xOES( GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q )
{
    struct glMultiTexCoord4xOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "texture %d, s %d, t %d, r %d, q %d\n", texture, s, t, r, q );
    if ((status = UNIX_CALL( glMultiTexCoord4xOES, &args ))) WARN( "glMultiTexCoord4xOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoord4xvOES( GLenum texture, const GLfixed *coords )
{
    struct glMultiTexCoord4xvOES_params args = { .teb = NtCurrentTeb(), .texture = texture, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, coords %p\n", texture, coords );
    if ((status = UNIX_CALL( glMultiTexCoord4xvOES, &args ))) WARN( "glMultiTexCoord4xvOES returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordP1ui( GLenum texture, GLenum type, GLuint coords )
{
    struct glMultiTexCoordP1ui_params args = { .teb = NtCurrentTeb(), .texture = texture, .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, type %d, coords %d\n", texture, type, coords );
    if ((status = UNIX_CALL( glMultiTexCoordP1ui, &args ))) WARN( "glMultiTexCoordP1ui returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordP1uiv( GLenum texture, GLenum type, const GLuint *coords )
{
    struct glMultiTexCoordP1uiv_params args = { .teb = NtCurrentTeb(), .texture = texture, .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, type %d, coords %p\n", texture, type, coords );
    if ((status = UNIX_CALL( glMultiTexCoordP1uiv, &args ))) WARN( "glMultiTexCoordP1uiv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordP2ui( GLenum texture, GLenum type, GLuint coords )
{
    struct glMultiTexCoordP2ui_params args = { .teb = NtCurrentTeb(), .texture = texture, .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, type %d, coords %d\n", texture, type, coords );
    if ((status = UNIX_CALL( glMultiTexCoordP2ui, &args ))) WARN( "glMultiTexCoordP2ui returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordP2uiv( GLenum texture, GLenum type, const GLuint *coords )
{
    struct glMultiTexCoordP2uiv_params args = { .teb = NtCurrentTeb(), .texture = texture, .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, type %d, coords %p\n", texture, type, coords );
    if ((status = UNIX_CALL( glMultiTexCoordP2uiv, &args ))) WARN( "glMultiTexCoordP2uiv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordP3ui( GLenum texture, GLenum type, GLuint coords )
{
    struct glMultiTexCoordP3ui_params args = { .teb = NtCurrentTeb(), .texture = texture, .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, type %d, coords %d\n", texture, type, coords );
    if ((status = UNIX_CALL( glMultiTexCoordP3ui, &args ))) WARN( "glMultiTexCoordP3ui returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordP3uiv( GLenum texture, GLenum type, const GLuint *coords )
{
    struct glMultiTexCoordP3uiv_params args = { .teb = NtCurrentTeb(), .texture = texture, .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, type %d, coords %p\n", texture, type, coords );
    if ((status = UNIX_CALL( glMultiTexCoordP3uiv, &args ))) WARN( "glMultiTexCoordP3uiv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordP4ui( GLenum texture, GLenum type, GLuint coords )
{
    struct glMultiTexCoordP4ui_params args = { .teb = NtCurrentTeb(), .texture = texture, .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, type %d, coords %d\n", texture, type, coords );
    if ((status = UNIX_CALL( glMultiTexCoordP4ui, &args ))) WARN( "glMultiTexCoordP4ui returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordP4uiv( GLenum texture, GLenum type, const GLuint *coords )
{
    struct glMultiTexCoordP4uiv_params args = { .teb = NtCurrentTeb(), .texture = texture, .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "texture %d, type %d, coords %p\n", texture, type, coords );
    if ((status = UNIX_CALL( glMultiTexCoordP4uiv, &args ))) WARN( "glMultiTexCoordP4uiv returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordPointerEXT( GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glMultiTexCoordPointerEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "texunit %d, size %d, type %d, stride %d, pointer %p\n", texunit, size, type, stride, pointer );
    if ((status = UNIX_CALL( glMultiTexCoordPointerEXT, &args ))) WARN( "glMultiTexCoordPointerEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexCoordPointerSGIS( GLenum target, GLint size, GLenum type, GLsizei stride, GLvoid * pointer )
{
    struct glMultiTexCoordPointerSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "target %d, size %d, type %d, stride %d, pointer %p\n", target, size, type, stride, pointer );
    if ((status = UNIX_CALL( glMultiTexCoordPointerSGIS, &args ))) WARN( "glMultiTexCoordPointerSGIS returned %#lx\n", status );
}

static void WINAPI glMultiTexEnvfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param )
{
    struct glMultiTexEnvfEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, param %f\n", texunit, target, pname, param );
    if ((status = UNIX_CALL( glMultiTexEnvfEXT, &args ))) WARN( "glMultiTexEnvfEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat *params )
{
    struct glMultiTexEnvfvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glMultiTexEnvfvEXT, &args ))) WARN( "glMultiTexEnvfvEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexEnviEXT( GLenum texunit, GLenum target, GLenum pname, GLint param )
{
    struct glMultiTexEnviEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, param %d\n", texunit, target, pname, param );
    if ((status = UNIX_CALL( glMultiTexEnviEXT, &args ))) WARN( "glMultiTexEnviEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params )
{
    struct glMultiTexEnvivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glMultiTexEnvivEXT, &args ))) WARN( "glMultiTexEnvivEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexGendEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble param )
{
    struct glMultiTexGendEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, param %f\n", texunit, coord, pname, param );
    if ((status = UNIX_CALL( glMultiTexGendEXT, &args ))) WARN( "glMultiTexGendEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params )
{
    struct glMultiTexGendvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, params %p\n", texunit, coord, pname, params );
    if ((status = UNIX_CALL( glMultiTexGendvEXT, &args ))) WARN( "glMultiTexGendvEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexGenfEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat param )
{
    struct glMultiTexGenfEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, param %f\n", texunit, coord, pname, param );
    if ((status = UNIX_CALL( glMultiTexGenfEXT, &args ))) WARN( "glMultiTexGenfEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params )
{
    struct glMultiTexGenfvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, params %p\n", texunit, coord, pname, params );
    if ((status = UNIX_CALL( glMultiTexGenfvEXT, &args ))) WARN( "glMultiTexGenfvEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexGeniEXT( GLenum texunit, GLenum coord, GLenum pname, GLint param )
{
    struct glMultiTexGeniEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, param %d\n", texunit, coord, pname, param );
    if ((status = UNIX_CALL( glMultiTexGeniEXT, &args ))) WARN( "glMultiTexGeniEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, const GLint *params )
{
    struct glMultiTexGenivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, coord %d, pname %d, params %p\n", texunit, coord, pname, params );
    if ((status = UNIX_CALL( glMultiTexGenivEXT, &args ))) WARN( "glMultiTexGenivEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glMultiTexImage1DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .internalformat = internalformat, .width = width, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, internalformat %d, width %d, border %d, format %d, type %d, pixels %p\n", texunit, target, level, internalformat, width, border, format, type, pixels );
    if ((status = UNIX_CALL( glMultiTexImage1DEXT, &args ))) WARN( "glMultiTexImage1DEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glMultiTexImage2DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, internalformat %d, width %d, height %d, border %d, format %d, type %d, pixels %p\n", texunit, target, level, internalformat, width, height, border, format, type, pixels );
    if ((status = UNIX_CALL( glMultiTexImage2DEXT, &args ))) WARN( "glMultiTexImage2DEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glMultiTexImage3DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, internalformat %d, width %d, height %d, depth %d, border %d, format %d, type %d, pixels %p\n", texunit, target, level, internalformat, width, height, depth, border, format, type, pixels );
    if ((status = UNIX_CALL( glMultiTexImage3DEXT, &args ))) WARN( "glMultiTexImage3DEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params )
{
    struct glMultiTexParameterIivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glMultiTexParameterIivEXT, &args ))) WARN( "glMultiTexParameterIivEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, const GLuint *params )
{
    struct glMultiTexParameterIuivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glMultiTexParameterIuivEXT, &args ))) WARN( "glMultiTexParameterIuivEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexParameterfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param )
{
    struct glMultiTexParameterfEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, param %f\n", texunit, target, pname, param );
    if ((status = UNIX_CALL( glMultiTexParameterfEXT, &args ))) WARN( "glMultiTexParameterfEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat *params )
{
    struct glMultiTexParameterfvEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glMultiTexParameterfvEXT, &args ))) WARN( "glMultiTexParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexParameteriEXT( GLenum texunit, GLenum target, GLenum pname, GLint param )
{
    struct glMultiTexParameteriEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, param %d\n", texunit, target, pname, param );
    if ((status = UNIX_CALL( glMultiTexParameteriEXT, &args ))) WARN( "glMultiTexParameteriEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params )
{
    struct glMultiTexParameterivEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, pname %d, params %p\n", texunit, target, pname, params );
    if ((status = UNIX_CALL( glMultiTexParameterivEXT, &args ))) WARN( "glMultiTexParameterivEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexRenderbufferEXT( GLenum texunit, GLenum target, GLuint renderbuffer )
{
    struct glMultiTexRenderbufferEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, renderbuffer %d\n", texunit, target, renderbuffer );
    if ((status = UNIX_CALL( glMultiTexRenderbufferEXT, &args ))) WARN( "glMultiTexRenderbufferEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
{
    struct glMultiTexSubImage1DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, width %d, format %d, type %d, pixels %p\n", texunit, target, level, xoffset, width, format, type, pixels );
    if ((status = UNIX_CALL( glMultiTexSubImage1DEXT, &args ))) WARN( "glMultiTexSubImage1DEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
{
    struct glMultiTexSubImage2DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, type %d, pixels %p\n", texunit, target, level, xoffset, yoffset, width, height, format, type, pixels );
    if ((status = UNIX_CALL( glMultiTexSubImage2DEXT, &args ))) WARN( "glMultiTexSubImage2DEXT returned %#lx\n", status );
}

static void WINAPI glMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
{
    struct glMultiTexSubImage3DEXT_params args = { .teb = NtCurrentTeb(), .texunit = texunit, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texunit %d, target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, type %d, pixels %p\n", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
    if ((status = UNIX_CALL( glMultiTexSubImage3DEXT, &args ))) WARN( "glMultiTexSubImage3DEXT returned %#lx\n", status );
}

static void WINAPI glMulticastBarrierNV(void)
{
    struct glMulticastBarrierNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glMulticastBarrierNV, &args ))) WARN( "glMulticastBarrierNV returned %#lx\n", status );
}

static void WINAPI glMulticastBlitFramebufferNV( GLuint srcGpu, GLuint dstGpu, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
{
    struct glMulticastBlitFramebufferNV_params args = { .teb = NtCurrentTeb(), .srcGpu = srcGpu, .dstGpu = dstGpu, .srcX0 = srcX0, .srcY0 = srcY0, .srcX1 = srcX1, .srcY1 = srcY1, .dstX0 = dstX0, .dstY0 = dstY0, .dstX1 = dstX1, .dstY1 = dstY1, .mask = mask, .filter = filter };
    NTSTATUS status;
    TRACE( "srcGpu %d, dstGpu %d, srcX0 %d, srcY0 %d, srcX1 %d, srcY1 %d, dstX0 %d, dstY0 %d, dstX1 %d, dstY1 %d, mask %d, filter %d\n", srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
    if ((status = UNIX_CALL( glMulticastBlitFramebufferNV, &args ))) WARN( "glMulticastBlitFramebufferNV returned %#lx\n", status );
}

static void WINAPI glMulticastBufferSubDataNV( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data )
{
    struct glMulticastBufferSubDataNV_params args = { .teb = NtCurrentTeb(), .gpuMask = gpuMask, .buffer = buffer, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "gpuMask %d, buffer %d, offset %Id, size %Id, data %p\n", gpuMask, buffer, offset, size, data );
    if ((status = UNIX_CALL( glMulticastBufferSubDataNV, &args ))) WARN( "glMulticastBufferSubDataNV returned %#lx\n", status );
}

static void WINAPI glMulticastCopyBufferSubDataNV( GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
{
    struct glMulticastCopyBufferSubDataNV_params args = { .teb = NtCurrentTeb(), .readGpu = readGpu, .writeGpuMask = writeGpuMask, .readBuffer = readBuffer, .writeBuffer = writeBuffer, .readOffset = readOffset, .writeOffset = writeOffset, .size = size };
    NTSTATUS status;
    TRACE( "readGpu %d, writeGpuMask %d, readBuffer %d, writeBuffer %d, readOffset %Id, writeOffset %Id, size %Id\n", readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size );
    if ((status = UNIX_CALL( glMulticastCopyBufferSubDataNV, &args ))) WARN( "glMulticastCopyBufferSubDataNV returned %#lx\n", status );
}

static void WINAPI glMulticastCopyImageSubDataNV( GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth )
{
    struct glMulticastCopyImageSubDataNV_params args = { .teb = NtCurrentTeb(), .srcGpu = srcGpu, .dstGpuMask = dstGpuMask, .srcName = srcName, .srcTarget = srcTarget, .srcLevel = srcLevel, .srcX = srcX, .srcY = srcY, .srcZ = srcZ, .dstName = dstName, .dstTarget = dstTarget, .dstLevel = dstLevel, .dstX = dstX, .dstY = dstY, .dstZ = dstZ, .srcWidth = srcWidth, .srcHeight = srcHeight, .srcDepth = srcDepth };
    NTSTATUS status;
    TRACE( "srcGpu %d, dstGpuMask %d, srcName %d, srcTarget %d, srcLevel %d, srcX %d, srcY %d, srcZ %d, dstName %d, dstTarget %d, dstLevel %d, dstX %d, dstY %d, dstZ %d, srcWidth %d, srcHeight %d, srcDepth %d\n", srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
    if ((status = UNIX_CALL( glMulticastCopyImageSubDataNV, &args ))) WARN( "glMulticastCopyImageSubDataNV returned %#lx\n", status );
}

static void WINAPI glMulticastFramebufferSampleLocationsfvNV( GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v )
{
    struct glMulticastFramebufferSampleLocationsfvNV_params args = { .teb = NtCurrentTeb(), .gpu = gpu, .framebuffer = framebuffer, .start = start, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "gpu %d, framebuffer %d, start %d, count %d, v %p\n", gpu, framebuffer, start, count, v );
    if ((status = UNIX_CALL( glMulticastFramebufferSampleLocationsfvNV, &args ))) WARN( "glMulticastFramebufferSampleLocationsfvNV returned %#lx\n", status );
}

static void WINAPI glMulticastGetQueryObjecti64vNV( GLuint gpu, GLuint id, GLenum pname, GLint64 *params )
{
    struct glMulticastGetQueryObjecti64vNV_params args = { .teb = NtCurrentTeb(), .gpu = gpu, .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "gpu %d, id %d, pname %d, params %p\n", gpu, id, pname, params );
    if ((status = UNIX_CALL( glMulticastGetQueryObjecti64vNV, &args ))) WARN( "glMulticastGetQueryObjecti64vNV returned %#lx\n", status );
}

static void WINAPI glMulticastGetQueryObjectivNV( GLuint gpu, GLuint id, GLenum pname, GLint *params )
{
    struct glMulticastGetQueryObjectivNV_params args = { .teb = NtCurrentTeb(), .gpu = gpu, .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "gpu %d, id %d, pname %d, params %p\n", gpu, id, pname, params );
    if ((status = UNIX_CALL( glMulticastGetQueryObjectivNV, &args ))) WARN( "glMulticastGetQueryObjectivNV returned %#lx\n", status );
}

static void WINAPI glMulticastGetQueryObjectui64vNV( GLuint gpu, GLuint id, GLenum pname, GLuint64 *params )
{
    struct glMulticastGetQueryObjectui64vNV_params args = { .teb = NtCurrentTeb(), .gpu = gpu, .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "gpu %d, id %d, pname %d, params %p\n", gpu, id, pname, params );
    if ((status = UNIX_CALL( glMulticastGetQueryObjectui64vNV, &args ))) WARN( "glMulticastGetQueryObjectui64vNV returned %#lx\n", status );
}

static void WINAPI glMulticastGetQueryObjectuivNV( GLuint gpu, GLuint id, GLenum pname, GLuint *params )
{
    struct glMulticastGetQueryObjectuivNV_params args = { .teb = NtCurrentTeb(), .gpu = gpu, .id = id, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "gpu %d, id %d, pname %d, params %p\n", gpu, id, pname, params );
    if ((status = UNIX_CALL( glMulticastGetQueryObjectuivNV, &args ))) WARN( "glMulticastGetQueryObjectuivNV returned %#lx\n", status );
}

static void WINAPI glMulticastScissorArrayvNVX( GLuint gpu, GLuint first, GLsizei count, const GLint *v )
{
    struct glMulticastScissorArrayvNVX_params args = { .teb = NtCurrentTeb(), .gpu = gpu, .first = first, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "gpu %d, first %d, count %d, v %p\n", gpu, first, count, v );
    if ((status = UNIX_CALL( glMulticastScissorArrayvNVX, &args ))) WARN( "glMulticastScissorArrayvNVX returned %#lx\n", status );
}

static void WINAPI glMulticastViewportArrayvNVX( GLuint gpu, GLuint first, GLsizei count, const GLfloat *v )
{
    struct glMulticastViewportArrayvNVX_params args = { .teb = NtCurrentTeb(), .gpu = gpu, .first = first, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "gpu %d, first %d, count %d, v %p\n", gpu, first, count, v );
    if ((status = UNIX_CALL( glMulticastViewportArrayvNVX, &args ))) WARN( "glMulticastViewportArrayvNVX returned %#lx\n", status );
}

static void WINAPI glMulticastViewportPositionWScaleNVX( GLuint gpu, GLuint index, GLfloat xcoeff, GLfloat ycoeff )
{
    struct glMulticastViewportPositionWScaleNVX_params args = { .teb = NtCurrentTeb(), .gpu = gpu, .index = index, .xcoeff = xcoeff, .ycoeff = ycoeff };
    NTSTATUS status;
    TRACE( "gpu %d, index %d, xcoeff %f, ycoeff %f\n", gpu, index, xcoeff, ycoeff );
    if ((status = UNIX_CALL( glMulticastViewportPositionWScaleNVX, &args ))) WARN( "glMulticastViewportPositionWScaleNVX returned %#lx\n", status );
}

static void WINAPI glMulticastWaitSyncNV( GLuint signalGpu, GLbitfield waitGpuMask )
{
    struct glMulticastWaitSyncNV_params args = { .teb = NtCurrentTeb(), .signalGpu = signalGpu, .waitGpuMask = waitGpuMask };
    NTSTATUS status;
    TRACE( "signalGpu %d, waitGpuMask %d\n", signalGpu, waitGpuMask );
    if ((status = UNIX_CALL( glMulticastWaitSyncNV, &args ))) WARN( "glMulticastWaitSyncNV returned %#lx\n", status );
}

static void WINAPI glNamedBufferAttachMemoryNV( GLuint buffer, GLuint memory, GLuint64 offset )
{
    struct glNamedBufferAttachMemoryNV_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "buffer %d, memory %d, offset %s\n", buffer, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glNamedBufferAttachMemoryNV, &args ))) WARN( "glNamedBufferAttachMemoryNV returned %#lx\n", status );
}

static void WINAPI glNamedBufferData( GLuint buffer, GLsizeiptr size, const void *data, GLenum usage )
{
    struct glNamedBufferData_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .size = size, .data = data, .usage = usage };
    NTSTATUS status;
    TRACE( "buffer %d, size %Id, data %p, usage %d\n", buffer, size, data, usage );
    if ((status = UNIX_CALL( glNamedBufferData, &args ))) WARN( "glNamedBufferData returned %#lx\n", status );
}

static void WINAPI glNamedBufferDataEXT( GLuint buffer, GLsizeiptr size, const void *data, GLenum usage )
{
    struct glNamedBufferDataEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .size = size, .data = data, .usage = usage };
    NTSTATUS status;
    TRACE( "buffer %d, size %Id, data %p, usage %d\n", buffer, size, data, usage );
    if ((status = UNIX_CALL( glNamedBufferDataEXT, &args ))) WARN( "glNamedBufferDataEXT returned %#lx\n", status );
}

static void WINAPI glNamedBufferPageCommitmentARB( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit )
{
    struct glNamedBufferPageCommitmentARB_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .size = size, .commit = commit };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, size %Id, commit %d\n", buffer, offset, size, commit );
    if ((status = UNIX_CALL( glNamedBufferPageCommitmentARB, &args ))) WARN( "glNamedBufferPageCommitmentARB returned %#lx\n", status );
}

static void WINAPI glNamedBufferPageCommitmentEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit )
{
    struct glNamedBufferPageCommitmentEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .size = size, .commit = commit };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, size %Id, commit %d\n", buffer, offset, size, commit );
    if ((status = UNIX_CALL( glNamedBufferPageCommitmentEXT, &args ))) WARN( "glNamedBufferPageCommitmentEXT returned %#lx\n", status );
}

static void WINAPI glNamedBufferStorage( GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags )
{
    struct glNamedBufferStorage_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .size = size, .data = data, .flags = flags };
    NTSTATUS status;
    TRACE( "buffer %d, size %Id, data %p, flags %d\n", buffer, size, data, flags );
    if ((status = UNIX_CALL( glNamedBufferStorage, &args ))) WARN( "glNamedBufferStorage returned %#lx\n", status );
}

static void WINAPI glNamedBufferStorageEXT( GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags )
{
    struct glNamedBufferStorageEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .size = size, .data = data, .flags = flags };
    NTSTATUS status;
    TRACE( "buffer %d, size %Id, data %p, flags %d\n", buffer, size, data, flags );
    if ((status = UNIX_CALL( glNamedBufferStorageEXT, &args ))) WARN( "glNamedBufferStorageEXT returned %#lx\n", status );
}

static void WINAPI glNamedBufferStorageExternalEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, GLeglClientBufferEXT clientBuffer, GLbitfield flags )
{
    struct glNamedBufferStorageExternalEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .size = size, .clientBuffer = clientBuffer, .flags = flags };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, size %Id, clientBuffer %p, flags %d\n", buffer, offset, size, clientBuffer, flags );
    if ((status = UNIX_CALL( glNamedBufferStorageExternalEXT, &args ))) WARN( "glNamedBufferStorageExternalEXT returned %#lx\n", status );
}

static void WINAPI glNamedBufferStorageMemEXT( GLuint buffer, GLsizeiptr size, GLuint memory, GLuint64 offset )
{
    struct glNamedBufferStorageMemEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .size = size, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "buffer %d, size %Id, memory %d, offset %s\n", buffer, size, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glNamedBufferStorageMemEXT, &args ))) WARN( "glNamedBufferStorageMemEXT returned %#lx\n", status );
}

static void WINAPI glNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data )
{
    struct glNamedBufferSubData_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, size %Id, data %p\n", buffer, offset, size, data );
    if ((status = UNIX_CALL( glNamedBufferSubData, &args ))) WARN( "glNamedBufferSubData returned %#lx\n", status );
}

static void WINAPI glNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data )
{
    struct glNamedBufferSubDataEXT_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .size = size, .data = data };
    NTSTATUS status;
    TRACE( "buffer %d, offset %Id, size %Id, data %p\n", buffer, offset, size, data );
    if ((status = UNIX_CALL( glNamedBufferSubDataEXT, &args ))) WARN( "glNamedBufferSubDataEXT returned %#lx\n", status );
}

static void WINAPI glNamedCopyBufferSubDataEXT( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
{
    struct glNamedCopyBufferSubDataEXT_params args = { .teb = NtCurrentTeb(), .readBuffer = readBuffer, .writeBuffer = writeBuffer, .readOffset = readOffset, .writeOffset = writeOffset, .size = size };
    NTSTATUS status;
    TRACE( "readBuffer %d, writeBuffer %d, readOffset %Id, writeOffset %Id, size %Id\n", readBuffer, writeBuffer, readOffset, writeOffset, size );
    if ((status = UNIX_CALL( glNamedCopyBufferSubDataEXT, &args ))) WARN( "glNamedCopyBufferSubDataEXT returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferDrawBuffer( GLuint framebuffer, GLenum buf )
{
    struct glNamedFramebufferDrawBuffer_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .buf = buf };
    NTSTATUS status;
    TRACE( "framebuffer %d, buf %d\n", framebuffer, buf );
    if ((status = UNIX_CALL( glNamedFramebufferDrawBuffer, &args ))) WARN( "glNamedFramebufferDrawBuffer returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferDrawBuffers( GLuint framebuffer, GLsizei n, const GLenum *bufs )
{
    struct glNamedFramebufferDrawBuffers_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .n = n, .bufs = bufs };
    NTSTATUS status;
    TRACE( "framebuffer %d, n %d, bufs %p\n", framebuffer, n, bufs );
    if ((status = UNIX_CALL( glNamedFramebufferDrawBuffers, &args ))) WARN( "glNamedFramebufferDrawBuffers returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferParameteri( GLuint framebuffer, GLenum pname, GLint param )
{
    struct glNamedFramebufferParameteri_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "framebuffer %d, pname %d, param %d\n", framebuffer, pname, param );
    if ((status = UNIX_CALL( glNamedFramebufferParameteri, &args ))) WARN( "glNamedFramebufferParameteri returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferParameteriEXT( GLuint framebuffer, GLenum pname, GLint param )
{
    struct glNamedFramebufferParameteriEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "framebuffer %d, pname %d, param %d\n", framebuffer, pname, param );
    if ((status = UNIX_CALL( glNamedFramebufferParameteriEXT, &args ))) WARN( "glNamedFramebufferParameteriEXT returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferReadBuffer( GLuint framebuffer, GLenum src )
{
    struct glNamedFramebufferReadBuffer_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .src = src };
    NTSTATUS status;
    TRACE( "framebuffer %d, src %d\n", framebuffer, src );
    if ((status = UNIX_CALL( glNamedFramebufferReadBuffer, &args ))) WARN( "glNamedFramebufferReadBuffer returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferRenderbuffer( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
{
    struct glNamedFramebufferRenderbuffer_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .renderbuffertarget = renderbuffertarget, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, renderbuffertarget %d, renderbuffer %d\n", framebuffer, attachment, renderbuffertarget, renderbuffer );
    if ((status = UNIX_CALL( glNamedFramebufferRenderbuffer, &args ))) WARN( "glNamedFramebufferRenderbuffer returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferRenderbufferEXT( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
{
    struct glNamedFramebufferRenderbufferEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .renderbuffertarget = renderbuffertarget, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, renderbuffertarget %d, renderbuffer %d\n", framebuffer, attachment, renderbuffertarget, renderbuffer );
    if ((status = UNIX_CALL( glNamedFramebufferRenderbufferEXT, &args ))) WARN( "glNamedFramebufferRenderbufferEXT returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferSampleLocationsfvARB( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v )
{
    struct glNamedFramebufferSampleLocationsfvARB_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .start = start, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "framebuffer %d, start %d, count %d, v %p\n", framebuffer, start, count, v );
    if ((status = UNIX_CALL( glNamedFramebufferSampleLocationsfvARB, &args ))) WARN( "glNamedFramebufferSampleLocationsfvARB returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferSampleLocationsfvNV( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v )
{
    struct glNamedFramebufferSampleLocationsfvNV_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .start = start, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "framebuffer %d, start %d, count %d, v %p\n", framebuffer, start, count, v );
    if ((status = UNIX_CALL( glNamedFramebufferSampleLocationsfvNV, &args ))) WARN( "glNamedFramebufferSampleLocationsfvNV returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferSamplePositionsfvAMD( GLuint framebuffer, GLuint numsamples, GLuint pixelindex, const GLfloat *values )
{
    struct glNamedFramebufferSamplePositionsfvAMD_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .numsamples = numsamples, .pixelindex = pixelindex, .values = values };
    NTSTATUS status;
    TRACE( "framebuffer %d, numsamples %d, pixelindex %d, values %p\n", framebuffer, numsamples, pixelindex, values );
    if ((status = UNIX_CALL( glNamedFramebufferSamplePositionsfvAMD, &args ))) WARN( "glNamedFramebufferSamplePositionsfvAMD returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferTexture( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level )
{
    struct glNamedFramebufferTexture_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, texture %d, level %d\n", framebuffer, attachment, texture, level );
    if ((status = UNIX_CALL( glNamedFramebufferTexture, &args ))) WARN( "glNamedFramebufferTexture returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferTexture1DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
    struct glNamedFramebufferTexture1DEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, textarget %d, texture %d, level %d\n", framebuffer, attachment, textarget, texture, level );
    if ((status = UNIX_CALL( glNamedFramebufferTexture1DEXT, &args ))) WARN( "glNamedFramebufferTexture1DEXT returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferTexture2DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
{
    struct glNamedFramebufferTexture2DEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, textarget %d, texture %d, level %d\n", framebuffer, attachment, textarget, texture, level );
    if ((status = UNIX_CALL( glNamedFramebufferTexture2DEXT, &args ))) WARN( "glNamedFramebufferTexture2DEXT returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferTexture3DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset )
{
    struct glNamedFramebufferTexture3DEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .textarget = textarget, .texture = texture, .level = level, .zoffset = zoffset };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, textarget %d, texture %d, level %d, zoffset %d\n", framebuffer, attachment, textarget, texture, level, zoffset );
    if ((status = UNIX_CALL( glNamedFramebufferTexture3DEXT, &args ))) WARN( "glNamedFramebufferTexture3DEXT returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferTextureEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level )
{
    struct glNamedFramebufferTextureEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, texture %d, level %d\n", framebuffer, attachment, texture, level );
    if ((status = UNIX_CALL( glNamedFramebufferTextureEXT, &args ))) WARN( "glNamedFramebufferTextureEXT returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferTextureFaceEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face )
{
    struct glNamedFramebufferTextureFaceEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .texture = texture, .level = level, .face = face };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, texture %d, level %d, face %d\n", framebuffer, attachment, texture, level, face );
    if ((status = UNIX_CALL( glNamedFramebufferTextureFaceEXT, &args ))) WARN( "glNamedFramebufferTextureFaceEXT returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferTextureLayer( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer )
{
    struct glNamedFramebufferTextureLayer_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .texture = texture, .level = level, .layer = layer };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, texture %d, level %d, layer %d\n", framebuffer, attachment, texture, level, layer );
    if ((status = UNIX_CALL( glNamedFramebufferTextureLayer, &args ))) WARN( "glNamedFramebufferTextureLayer returned %#lx\n", status );
}

static void WINAPI glNamedFramebufferTextureLayerEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer )
{
    struct glNamedFramebufferTextureLayerEXT_params args = { .teb = NtCurrentTeb(), .framebuffer = framebuffer, .attachment = attachment, .texture = texture, .level = level, .layer = layer };
    NTSTATUS status;
    TRACE( "framebuffer %d, attachment %d, texture %d, level %d, layer %d\n", framebuffer, attachment, texture, level, layer );
    if ((status = UNIX_CALL( glNamedFramebufferTextureLayerEXT, &args ))) WARN( "glNamedFramebufferTextureLayerEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameter4dEXT( GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glNamedProgramLocalParameter4dEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, x %f, y %f, z %f, w %f\n", program, target, index, x, y, z, w );
    if ((status = UNIX_CALL( glNamedProgramLocalParameter4dEXT, &args ))) WARN( "glNamedProgramLocalParameter4dEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameter4dvEXT( GLuint program, GLenum target, GLuint index, const GLdouble *params )
{
    struct glNamedProgramLocalParameter4dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, params %p\n", program, target, index, params );
    if ((status = UNIX_CALL( glNamedProgramLocalParameter4dvEXT, &args ))) WARN( "glNamedProgramLocalParameter4dvEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameter4fEXT( GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glNamedProgramLocalParameter4fEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, x %f, y %f, z %f, w %f\n", program, target, index, x, y, z, w );
    if ((status = UNIX_CALL( glNamedProgramLocalParameter4fEXT, &args ))) WARN( "glNamedProgramLocalParameter4fEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameter4fvEXT( GLuint program, GLenum target, GLuint index, const GLfloat *params )
{
    struct glNamedProgramLocalParameter4fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, params %p\n", program, target, index, params );
    if ((status = UNIX_CALL( glNamedProgramLocalParameter4fvEXT, &args ))) WARN( "glNamedProgramLocalParameter4fvEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameterI4iEXT( GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w )
{
    struct glNamedProgramLocalParameterI4iEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, x %d, y %d, z %d, w %d\n", program, target, index, x, y, z, w );
    if ((status = UNIX_CALL( glNamedProgramLocalParameterI4iEXT, &args ))) WARN( "glNamedProgramLocalParameterI4iEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameterI4ivEXT( GLuint program, GLenum target, GLuint index, const GLint *params )
{
    struct glNamedProgramLocalParameterI4ivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, params %p\n", program, target, index, params );
    if ((status = UNIX_CALL( glNamedProgramLocalParameterI4ivEXT, &args ))) WARN( "glNamedProgramLocalParameterI4ivEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameterI4uiEXT( GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
{
    struct glNamedProgramLocalParameterI4uiEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, x %d, y %d, z %d, w %d\n", program, target, index, x, y, z, w );
    if ((status = UNIX_CALL( glNamedProgramLocalParameterI4uiEXT, &args ))) WARN( "glNamedProgramLocalParameterI4uiEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameterI4uivEXT( GLuint program, GLenum target, GLuint index, const GLuint *params )
{
    struct glNamedProgramLocalParameterI4uivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, params %p\n", program, target, index, params );
    if ((status = UNIX_CALL( glNamedProgramLocalParameterI4uivEXT, &args ))) WARN( "glNamedProgramLocalParameterI4uivEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParameters4fvEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params )
{
    struct glNamedProgramLocalParameters4fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, count %d, params %p\n", program, target, index, count, params );
    if ((status = UNIX_CALL( glNamedProgramLocalParameters4fvEXT, &args ))) WARN( "glNamedProgramLocalParameters4fvEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParametersI4ivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params )
{
    struct glNamedProgramLocalParametersI4ivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, count %d, params %p\n", program, target, index, count, params );
    if ((status = UNIX_CALL( glNamedProgramLocalParametersI4ivEXT, &args ))) WARN( "glNamedProgramLocalParametersI4ivEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramLocalParametersI4uivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params )
{
    struct glNamedProgramLocalParametersI4uivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "program %d, target %d, index %d, count %d, params %p\n", program, target, index, count, params );
    if ((status = UNIX_CALL( glNamedProgramLocalParametersI4uivEXT, &args ))) WARN( "glNamedProgramLocalParametersI4uivEXT returned %#lx\n", status );
}

static void WINAPI glNamedProgramStringEXT( GLuint program, GLenum target, GLenum format, GLsizei len, const void *string )
{
    struct glNamedProgramStringEXT_params args = { .teb = NtCurrentTeb(), .program = program, .target = target, .format = format, .len = len, .string = string };
    NTSTATUS status;
    TRACE( "program %d, target %d, format %d, len %d, string %p\n", program, target, format, len, string );
    if ((status = UNIX_CALL( glNamedProgramStringEXT, &args ))) WARN( "glNamedProgramStringEXT returned %#lx\n", status );
}

static void WINAPI glNamedRenderbufferStorage( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glNamedRenderbufferStorage_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "renderbuffer %d, internalformat %d, width %d, height %d\n", renderbuffer, internalformat, width, height );
    if ((status = UNIX_CALL( glNamedRenderbufferStorage, &args ))) WARN( "glNamedRenderbufferStorage returned %#lx\n", status );
}

static void WINAPI glNamedRenderbufferStorageEXT( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glNamedRenderbufferStorageEXT_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "renderbuffer %d, internalformat %d, width %d, height %d\n", renderbuffer, internalformat, width, height );
    if ((status = UNIX_CALL( glNamedRenderbufferStorageEXT, &args ))) WARN( "glNamedRenderbufferStorageEXT returned %#lx\n", status );
}

static void WINAPI glNamedRenderbufferStorageMultisample( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glNamedRenderbufferStorageMultisample_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer, .samples = samples, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "renderbuffer %d, samples %d, internalformat %d, width %d, height %d\n", renderbuffer, samples, internalformat, width, height );
    if ((status = UNIX_CALL( glNamedRenderbufferStorageMultisample, &args ))) WARN( "glNamedRenderbufferStorageMultisample returned %#lx\n", status );
}

static void WINAPI glNamedRenderbufferStorageMultisampleAdvancedAMD( GLuint renderbuffer, GLsizei samples, GLsizei storageSamples, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glNamedRenderbufferStorageMultisampleAdvancedAMD_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer, .samples = samples, .storageSamples = storageSamples, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "renderbuffer %d, samples %d, storageSamples %d, internalformat %d, width %d, height %d\n", renderbuffer, samples, storageSamples, internalformat, width, height );
    if ((status = UNIX_CALL( glNamedRenderbufferStorageMultisampleAdvancedAMD, &args ))) WARN( "glNamedRenderbufferStorageMultisampleAdvancedAMD returned %#lx\n", status );
}

static void WINAPI glNamedRenderbufferStorageMultisampleCoverageEXT( GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glNamedRenderbufferStorageMultisampleCoverageEXT_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer, .coverageSamples = coverageSamples, .colorSamples = colorSamples, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "renderbuffer %d, coverageSamples %d, colorSamples %d, internalformat %d, width %d, height %d\n", renderbuffer, coverageSamples, colorSamples, internalformat, width, height );
    if ((status = UNIX_CALL( glNamedRenderbufferStorageMultisampleCoverageEXT, &args ))) WARN( "glNamedRenderbufferStorageMultisampleCoverageEXT returned %#lx\n", status );
}

static void WINAPI glNamedRenderbufferStorageMultisampleEXT( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glNamedRenderbufferStorageMultisampleEXT_params args = { .teb = NtCurrentTeb(), .renderbuffer = renderbuffer, .samples = samples, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "renderbuffer %d, samples %d, internalformat %d, width %d, height %d\n", renderbuffer, samples, internalformat, width, height );
    if ((status = UNIX_CALL( glNamedRenderbufferStorageMultisampleEXT, &args ))) WARN( "glNamedRenderbufferStorageMultisampleEXT returned %#lx\n", status );
}

static void WINAPI glNamedStringARB( GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string )
{
    struct glNamedStringARB_params args = { .teb = NtCurrentTeb(), .type = type, .namelen = namelen, .name = name, .stringlen = stringlen, .string = string };
    NTSTATUS status;
    TRACE( "type %d, namelen %d, name %p, stringlen %d, string %p\n", type, namelen, name, stringlen, string );
    if ((status = UNIX_CALL( glNamedStringARB, &args ))) WARN( "glNamedStringARB returned %#lx\n", status );
}

static GLuint WINAPI glNewBufferRegion( GLenum type )
{
    struct glNewBufferRegion_params args = { .teb = NtCurrentTeb(), .type = type };
    NTSTATUS status;
    TRACE( "type %d\n", type );
    if ((status = UNIX_CALL( glNewBufferRegion, &args ))) WARN( "glNewBufferRegion returned %#lx\n", status );
    return args.ret;
}

static GLuint WINAPI glNewObjectBufferATI( GLsizei size, const void *pointer, GLenum usage )
{
    struct glNewObjectBufferATI_params args = { .teb = NtCurrentTeb(), .size = size, .pointer = pointer, .usage = usage };
    NTSTATUS status;
    TRACE( "size %d, pointer %p, usage %d\n", size, pointer, usage );
    if ((status = UNIX_CALL( glNewObjectBufferATI, &args ))) WARN( "glNewObjectBufferATI returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glNormal3fVertex3fSUN( GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
{
    struct glNormal3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "nx %f, ny %f, nz %f, x %f, y %f, z %f\n", nx, ny, nz, x, y, z );
    if ((status = UNIX_CALL( glNormal3fVertex3fSUN, &args ))) WARN( "glNormal3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glNormal3fVertex3fvSUN( const GLfloat *n, const GLfloat *v )
{
    struct glNormal3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .n = n, .v = v };
    NTSTATUS status;
    TRACE( "n %p, v %p\n", n, v );
    if ((status = UNIX_CALL( glNormal3fVertex3fvSUN, &args ))) WARN( "glNormal3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glNormal3hNV( GLhalfNV nx, GLhalfNV ny, GLhalfNV nz )
{
    struct glNormal3hNV_params args = { .teb = NtCurrentTeb(), .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "nx %d, ny %d, nz %d\n", nx, ny, nz );
    if ((status = UNIX_CALL( glNormal3hNV, &args ))) WARN( "glNormal3hNV returned %#lx\n", status );
}

static void WINAPI glNormal3hvNV( const GLhalfNV *v )
{
    struct glNormal3hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glNormal3hvNV, &args ))) WARN( "glNormal3hvNV returned %#lx\n", status );
}

static void WINAPI glNormal3xOES( GLfixed nx, GLfixed ny, GLfixed nz )
{
    struct glNormal3xOES_params args = { .teb = NtCurrentTeb(), .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "nx %d, ny %d, nz %d\n", nx, ny, nz );
    if ((status = UNIX_CALL( glNormal3xOES, &args ))) WARN( "glNormal3xOES returned %#lx\n", status );
}

static void WINAPI glNormal3xvOES( const GLfixed *coords )
{
    struct glNormal3xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glNormal3xvOES, &args ))) WARN( "glNormal3xvOES returned %#lx\n", status );
}

static void WINAPI glNormalFormatNV( GLenum type, GLsizei stride )
{
    struct glNormalFormatNV_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "type %d, stride %d\n", type, stride );
    if ((status = UNIX_CALL( glNormalFormatNV, &args ))) WARN( "glNormalFormatNV returned %#lx\n", status );
}

static void WINAPI glNormalP3ui( GLenum type, GLuint coords )
{
    struct glNormalP3ui_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %d\n", type, coords );
    if ((status = UNIX_CALL( glNormalP3ui, &args ))) WARN( "glNormalP3ui returned %#lx\n", status );
}

static void WINAPI glNormalP3uiv( GLenum type, const GLuint *coords )
{
    struct glNormalP3uiv_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %p\n", type, coords );
    if ((status = UNIX_CALL( glNormalP3uiv, &args ))) WARN( "glNormalP3uiv returned %#lx\n", status );
}

static void WINAPI glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void *pointer )
{
    struct glNormalPointerEXT_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .count = count, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, count %d, pointer %p\n", type, stride, count, pointer );
    if ((status = UNIX_CALL( glNormalPointerEXT, &args ))) WARN( "glNormalPointerEXT returned %#lx\n", status );
}

static void WINAPI glNormalPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride )
{
    struct glNormalPointerListIBM_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer, .ptrstride = ptrstride };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p, ptrstride %d\n", type, stride, pointer, ptrstride );
    if ((status = UNIX_CALL( glNormalPointerListIBM, &args ))) WARN( "glNormalPointerListIBM returned %#lx\n", status );
}

static void WINAPI glNormalPointervINTEL( GLenum type, const void **pointer )
{
    struct glNormalPointervINTEL_params args = { .teb = NtCurrentTeb(), .type = type, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, pointer %p\n", type, pointer );
    if ((status = UNIX_CALL( glNormalPointervINTEL, &args ))) WARN( "glNormalPointervINTEL returned %#lx\n", status );
}

static void WINAPI glNormalStream3bATI( GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz )
{
    struct glNormalStream3bATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "stream %d, nx %d, ny %d, nz %d\n", stream, nx, ny, nz );
    if ((status = UNIX_CALL( glNormalStream3bATI, &args ))) WARN( "glNormalStream3bATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3bvATI( GLenum stream, const GLbyte *coords )
{
    struct glNormalStream3bvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glNormalStream3bvATI, &args ))) WARN( "glNormalStream3bvATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3dATI( GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz )
{
    struct glNormalStream3dATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "stream %d, nx %f, ny %f, nz %f\n", stream, nx, ny, nz );
    if ((status = UNIX_CALL( glNormalStream3dATI, &args ))) WARN( "glNormalStream3dATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3dvATI( GLenum stream, const GLdouble *coords )
{
    struct glNormalStream3dvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glNormalStream3dvATI, &args ))) WARN( "glNormalStream3dvATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3fATI( GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz )
{
    struct glNormalStream3fATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "stream %d, nx %f, ny %f, nz %f\n", stream, nx, ny, nz );
    if ((status = UNIX_CALL( glNormalStream3fATI, &args ))) WARN( "glNormalStream3fATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3fvATI( GLenum stream, const GLfloat *coords )
{
    struct glNormalStream3fvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glNormalStream3fvATI, &args ))) WARN( "glNormalStream3fvATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3iATI( GLenum stream, GLint nx, GLint ny, GLint nz )
{
    struct glNormalStream3iATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "stream %d, nx %d, ny %d, nz %d\n", stream, nx, ny, nz );
    if ((status = UNIX_CALL( glNormalStream3iATI, &args ))) WARN( "glNormalStream3iATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3ivATI( GLenum stream, const GLint *coords )
{
    struct glNormalStream3ivATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glNormalStream3ivATI, &args ))) WARN( "glNormalStream3ivATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3sATI( GLenum stream, GLshort nx, GLshort ny, GLshort nz )
{
    struct glNormalStream3sATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .nx = nx, .ny = ny, .nz = nz };
    NTSTATUS status;
    TRACE( "stream %d, nx %d, ny %d, nz %d\n", stream, nx, ny, nz );
    if ((status = UNIX_CALL( glNormalStream3sATI, &args ))) WARN( "glNormalStream3sATI returned %#lx\n", status );
}

static void WINAPI glNormalStream3svATI( GLenum stream, const GLshort *coords )
{
    struct glNormalStream3svATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glNormalStream3svATI, &args ))) WARN( "glNormalStream3svATI returned %#lx\n", status );
}

static void WINAPI glObjectLabel( GLenum identifier, GLuint name, GLsizei length, const GLchar *label )
{
    struct glObjectLabel_params args = { .teb = NtCurrentTeb(), .identifier = identifier, .name = name, .length = length, .label = label };
    NTSTATUS status;
    TRACE( "identifier %d, name %d, length %d, label %p\n", identifier, name, length, label );
    if ((status = UNIX_CALL( glObjectLabel, &args ))) WARN( "glObjectLabel returned %#lx\n", status );
}

static void WINAPI glObjectPtrLabel( const void *ptr, GLsizei length, const GLchar *label )
{
    struct glObjectPtrLabel_params args = { .teb = NtCurrentTeb(), .ptr = ptr, .length = length, .label = label };
    NTSTATUS status;
    TRACE( "ptr %p, length %d, label %p\n", ptr, length, label );
    if ((status = UNIX_CALL( glObjectPtrLabel, &args ))) WARN( "glObjectPtrLabel returned %#lx\n", status );
}

static GLenum WINAPI glObjectPurgeableAPPLE( GLenum objectType, GLuint name, GLenum option )
{
    struct glObjectPurgeableAPPLE_params args = { .teb = NtCurrentTeb(), .objectType = objectType, .name = name, .option = option };
    NTSTATUS status;
    TRACE( "objectType %d, name %d, option %d\n", objectType, name, option );
    if ((status = UNIX_CALL( glObjectPurgeableAPPLE, &args ))) WARN( "glObjectPurgeableAPPLE returned %#lx\n", status );
    return args.ret;
}

static GLenum WINAPI glObjectUnpurgeableAPPLE( GLenum objectType, GLuint name, GLenum option )
{
    struct glObjectUnpurgeableAPPLE_params args = { .teb = NtCurrentTeb(), .objectType = objectType, .name = name, .option = option };
    NTSTATUS status;
    TRACE( "objectType %d, name %d, option %d\n", objectType, name, option );
    if ((status = UNIX_CALL( glObjectUnpurgeableAPPLE, &args ))) WARN( "glObjectUnpurgeableAPPLE returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glOrthofOES( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f )
{
    struct glOrthofOES_params args = { .teb = NtCurrentTeb(), .l = l, .r = r, .b = b, .t = t, .n = n, .f = f };
    NTSTATUS status;
    TRACE( "l %f, r %f, b %f, t %f, n %f, f %f\n", l, r, b, t, n, f );
    if ((status = UNIX_CALL( glOrthofOES, &args ))) WARN( "glOrthofOES returned %#lx\n", status );
}

static void WINAPI glOrthoxOES( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f )
{
    struct glOrthoxOES_params args = { .teb = NtCurrentTeb(), .l = l, .r = r, .b = b, .t = t, .n = n, .f = f };
    NTSTATUS status;
    TRACE( "l %d, r %d, b %d, t %d, n %d, f %d\n", l, r, b, t, n, f );
    if ((status = UNIX_CALL( glOrthoxOES, &args ))) WARN( "glOrthoxOES returned %#lx\n", status );
}

static void WINAPI glPNTrianglesfATI( GLenum pname, GLfloat param )
{
    struct glPNTrianglesfATI_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glPNTrianglesfATI, &args ))) WARN( "glPNTrianglesfATI returned %#lx\n", status );
}

static void WINAPI glPNTrianglesiATI( GLenum pname, GLint param )
{
    struct glPNTrianglesiATI_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glPNTrianglesiATI, &args ))) WARN( "glPNTrianglesiATI returned %#lx\n", status );
}

static void WINAPI glPassTexCoordATI( GLuint dst, GLuint coord, GLenum swizzle )
{
    struct glPassTexCoordATI_params args = { .teb = NtCurrentTeb(), .dst = dst, .coord = coord, .swizzle = swizzle };
    NTSTATUS status;
    TRACE( "dst %d, coord %d, swizzle %d\n", dst, coord, swizzle );
    if ((status = UNIX_CALL( glPassTexCoordATI, &args ))) WARN( "glPassTexCoordATI returned %#lx\n", status );
}

static void WINAPI glPassThroughxOES( GLfixed token )
{
    struct glPassThroughxOES_params args = { .teb = NtCurrentTeb(), .token = token };
    NTSTATUS status;
    TRACE( "token %d\n", token );
    if ((status = UNIX_CALL( glPassThroughxOES, &args ))) WARN( "glPassThroughxOES returned %#lx\n", status );
}

static void WINAPI glPatchParameterfv( GLenum pname, const GLfloat *values )
{
    struct glPatchParameterfv_params args = { .teb = NtCurrentTeb(), .pname = pname, .values = values };
    NTSTATUS status;
    TRACE( "pname %d, values %p\n", pname, values );
    if ((status = UNIX_CALL( glPatchParameterfv, &args ))) WARN( "glPatchParameterfv returned %#lx\n", status );
}

static void WINAPI glPatchParameteri( GLenum pname, GLint value )
{
    struct glPatchParameteri_params args = { .teb = NtCurrentTeb(), .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "pname %d, value %d\n", pname, value );
    if ((status = UNIX_CALL( glPatchParameteri, &args ))) WARN( "glPatchParameteri returned %#lx\n", status );
}

static void WINAPI glPathColorGenNV( GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat *coeffs )
{
    struct glPathColorGenNV_params args = { .teb = NtCurrentTeb(), .color = color, .genMode = genMode, .colorFormat = colorFormat, .coeffs = coeffs };
    NTSTATUS status;
    TRACE( "color %d, genMode %d, colorFormat %d, coeffs %p\n", color, genMode, colorFormat, coeffs );
    if ((status = UNIX_CALL( glPathColorGenNV, &args ))) WARN( "glPathColorGenNV returned %#lx\n", status );
}

static void WINAPI glPathCommandsNV( GLuint path, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords )
{
    struct glPathCommandsNV_params args = { .teb = NtCurrentTeb(), .path = path, .numCommands = numCommands, .commands = commands, .numCoords = numCoords, .coordType = coordType, .coords = coords };
    NTSTATUS status;
    TRACE( "path %d, numCommands %d, commands %p, numCoords %d, coordType %d, coords %p\n", path, numCommands, commands, numCoords, coordType, coords );
    if ((status = UNIX_CALL( glPathCommandsNV, &args ))) WARN( "glPathCommandsNV returned %#lx\n", status );
}

static void WINAPI glPathCoordsNV( GLuint path, GLsizei numCoords, GLenum coordType, const void *coords )
{
    struct glPathCoordsNV_params args = { .teb = NtCurrentTeb(), .path = path, .numCoords = numCoords, .coordType = coordType, .coords = coords };
    NTSTATUS status;
    TRACE( "path %d, numCoords %d, coordType %d, coords %p\n", path, numCoords, coordType, coords );
    if ((status = UNIX_CALL( glPathCoordsNV, &args ))) WARN( "glPathCoordsNV returned %#lx\n", status );
}

static void WINAPI glPathCoverDepthFuncNV( GLenum func )
{
    struct glPathCoverDepthFuncNV_params args = { .teb = NtCurrentTeb(), .func = func };
    NTSTATUS status;
    TRACE( "func %d\n", func );
    if ((status = UNIX_CALL( glPathCoverDepthFuncNV, &args ))) WARN( "glPathCoverDepthFuncNV returned %#lx\n", status );
}

static void WINAPI glPathDashArrayNV( GLuint path, GLsizei dashCount, const GLfloat *dashArray )
{
    struct glPathDashArrayNV_params args = { .teb = NtCurrentTeb(), .path = path, .dashCount = dashCount, .dashArray = dashArray };
    NTSTATUS status;
    TRACE( "path %d, dashCount %d, dashArray %p\n", path, dashCount, dashArray );
    if ((status = UNIX_CALL( glPathDashArrayNV, &args ))) WARN( "glPathDashArrayNV returned %#lx\n", status );
}

static void WINAPI glPathFogGenNV( GLenum genMode )
{
    struct glPathFogGenNV_params args = { .teb = NtCurrentTeb(), .genMode = genMode };
    NTSTATUS status;
    TRACE( "genMode %d\n", genMode );
    if ((status = UNIX_CALL( glPathFogGenNV, &args ))) WARN( "glPathFogGenNV returned %#lx\n", status );
}

static GLenum WINAPI glPathGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale )
{
    struct glPathGlyphIndexArrayNV_params args = { .teb = NtCurrentTeb(), .firstPathName = firstPathName, .fontTarget = fontTarget, .fontName = fontName, .fontStyle = fontStyle, .firstGlyphIndex = firstGlyphIndex, .numGlyphs = numGlyphs, .pathParameterTemplate = pathParameterTemplate, .emScale = emScale };
    NTSTATUS status;
    TRACE( "firstPathName %d, fontTarget %d, fontName %p, fontStyle %d, firstGlyphIndex %d, numGlyphs %d, pathParameterTemplate %d, emScale %f\n", firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale );
    if ((status = UNIX_CALL( glPathGlyphIndexArrayNV, &args ))) WARN( "glPathGlyphIndexArrayNV returned %#lx\n", status );
    return args.ret;
}

static GLenum WINAPI glPathGlyphIndexRangeNV( GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2] )
{
    struct glPathGlyphIndexRangeNV_params args = { .teb = NtCurrentTeb(), .fontTarget = fontTarget, .fontName = fontName, .fontStyle = fontStyle, .pathParameterTemplate = pathParameterTemplate, .emScale = emScale };
    NTSTATUS status;
    memcpy( args.baseAndCount, baseAndCount, sizeof(args.baseAndCount) );
    TRACE( "fontTarget %d, fontName %p, fontStyle %d, pathParameterTemplate %d, emScale %f, baseAndCount %p\n", fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount );
    if ((status = UNIX_CALL( glPathGlyphIndexRangeNV, &args ))) WARN( "glPathGlyphIndexRangeNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glPathGlyphRangeNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale )
{
    struct glPathGlyphRangeNV_params args = { .teb = NtCurrentTeb(), .firstPathName = firstPathName, .fontTarget = fontTarget, .fontName = fontName, .fontStyle = fontStyle, .firstGlyph = firstGlyph, .numGlyphs = numGlyphs, .handleMissingGlyphs = handleMissingGlyphs, .pathParameterTemplate = pathParameterTemplate, .emScale = emScale };
    NTSTATUS status;
    TRACE( "firstPathName %d, fontTarget %d, fontName %p, fontStyle %d, firstGlyph %d, numGlyphs %d, handleMissingGlyphs %d, pathParameterTemplate %d, emScale %f\n", firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale );
    if ((status = UNIX_CALL( glPathGlyphRangeNV, &args ))) WARN( "glPathGlyphRangeNV returned %#lx\n", status );
}

static void WINAPI glPathGlyphsNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void *charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale )
{
    struct glPathGlyphsNV_params args = { .teb = NtCurrentTeb(), .firstPathName = firstPathName, .fontTarget = fontTarget, .fontName = fontName, .fontStyle = fontStyle, .numGlyphs = numGlyphs, .type = type, .charcodes = charcodes, .handleMissingGlyphs = handleMissingGlyphs, .pathParameterTemplate = pathParameterTemplate, .emScale = emScale };
    NTSTATUS status;
    TRACE( "firstPathName %d, fontTarget %d, fontName %p, fontStyle %d, numGlyphs %d, type %d, charcodes %p, handleMissingGlyphs %d, pathParameterTemplate %d, emScale %f\n", firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale );
    if ((status = UNIX_CALL( glPathGlyphsNV, &args ))) WARN( "glPathGlyphsNV returned %#lx\n", status );
}

static GLenum WINAPI glPathMemoryGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale )
{
    struct glPathMemoryGlyphIndexArrayNV_params args = { .teb = NtCurrentTeb(), .firstPathName = firstPathName, .fontTarget = fontTarget, .fontSize = fontSize, .fontData = fontData, .faceIndex = faceIndex, .firstGlyphIndex = firstGlyphIndex, .numGlyphs = numGlyphs, .pathParameterTemplate = pathParameterTemplate, .emScale = emScale };
    NTSTATUS status;
    TRACE( "firstPathName %d, fontTarget %d, fontSize %Id, fontData %p, faceIndex %d, firstGlyphIndex %d, numGlyphs %d, pathParameterTemplate %d, emScale %f\n", firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale );
    if ((status = UNIX_CALL( glPathMemoryGlyphIndexArrayNV, &args ))) WARN( "glPathMemoryGlyphIndexArrayNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glPathParameterfNV( GLuint path, GLenum pname, GLfloat value )
{
    struct glPathParameterfNV_params args = { .teb = NtCurrentTeb(), .path = path, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "path %d, pname %d, value %f\n", path, pname, value );
    if ((status = UNIX_CALL( glPathParameterfNV, &args ))) WARN( "glPathParameterfNV returned %#lx\n", status );
}

static void WINAPI glPathParameterfvNV( GLuint path, GLenum pname, const GLfloat *value )
{
    struct glPathParameterfvNV_params args = { .teb = NtCurrentTeb(), .path = path, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "path %d, pname %d, value %p\n", path, pname, value );
    if ((status = UNIX_CALL( glPathParameterfvNV, &args ))) WARN( "glPathParameterfvNV returned %#lx\n", status );
}

static void WINAPI glPathParameteriNV( GLuint path, GLenum pname, GLint value )
{
    struct glPathParameteriNV_params args = { .teb = NtCurrentTeb(), .path = path, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "path %d, pname %d, value %d\n", path, pname, value );
    if ((status = UNIX_CALL( glPathParameteriNV, &args ))) WARN( "glPathParameteriNV returned %#lx\n", status );
}

static void WINAPI glPathParameterivNV( GLuint path, GLenum pname, const GLint *value )
{
    struct glPathParameterivNV_params args = { .teb = NtCurrentTeb(), .path = path, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "path %d, pname %d, value %p\n", path, pname, value );
    if ((status = UNIX_CALL( glPathParameterivNV, &args ))) WARN( "glPathParameterivNV returned %#lx\n", status );
}

static void WINAPI glPathStencilDepthOffsetNV( GLfloat factor, GLfloat units )
{
    struct glPathStencilDepthOffsetNV_params args = { .teb = NtCurrentTeb(), .factor = factor, .units = units };
    NTSTATUS status;
    TRACE( "factor %f, units %f\n", factor, units );
    if ((status = UNIX_CALL( glPathStencilDepthOffsetNV, &args ))) WARN( "glPathStencilDepthOffsetNV returned %#lx\n", status );
}

static void WINAPI glPathStencilFuncNV( GLenum func, GLint ref, GLuint mask )
{
    struct glPathStencilFuncNV_params args = { .teb = NtCurrentTeb(), .func = func, .ref = ref, .mask = mask };
    NTSTATUS status;
    TRACE( "func %d, ref %d, mask %d\n", func, ref, mask );
    if ((status = UNIX_CALL( glPathStencilFuncNV, &args ))) WARN( "glPathStencilFuncNV returned %#lx\n", status );
}

static void WINAPI glPathStringNV( GLuint path, GLenum format, GLsizei length, const void *pathString )
{
    struct glPathStringNV_params args = { .teb = NtCurrentTeb(), .path = path, .format = format, .length = length, .pathString = pathString };
    NTSTATUS status;
    TRACE( "path %d, format %d, length %d, pathString %p\n", path, format, length, pathString );
    if ((status = UNIX_CALL( glPathStringNV, &args ))) WARN( "glPathStringNV returned %#lx\n", status );
}

static void WINAPI glPathSubCommandsNV( GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords )
{
    struct glPathSubCommandsNV_params args = { .teb = NtCurrentTeb(), .path = path, .commandStart = commandStart, .commandsToDelete = commandsToDelete, .numCommands = numCommands, .commands = commands, .numCoords = numCoords, .coordType = coordType, .coords = coords };
    NTSTATUS status;
    TRACE( "path %d, commandStart %d, commandsToDelete %d, numCommands %d, commands %p, numCoords %d, coordType %d, coords %p\n", path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords );
    if ((status = UNIX_CALL( glPathSubCommandsNV, &args ))) WARN( "glPathSubCommandsNV returned %#lx\n", status );
}

static void WINAPI glPathSubCoordsNV( GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void *coords )
{
    struct glPathSubCoordsNV_params args = { .teb = NtCurrentTeb(), .path = path, .coordStart = coordStart, .numCoords = numCoords, .coordType = coordType, .coords = coords };
    NTSTATUS status;
    TRACE( "path %d, coordStart %d, numCoords %d, coordType %d, coords %p\n", path, coordStart, numCoords, coordType, coords );
    if ((status = UNIX_CALL( glPathSubCoordsNV, &args ))) WARN( "glPathSubCoordsNV returned %#lx\n", status );
}

static void WINAPI glPathTexGenNV( GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat *coeffs )
{
    struct glPathTexGenNV_params args = { .teb = NtCurrentTeb(), .texCoordSet = texCoordSet, .genMode = genMode, .components = components, .coeffs = coeffs };
    NTSTATUS status;
    TRACE( "texCoordSet %d, genMode %d, components %d, coeffs %p\n", texCoordSet, genMode, components, coeffs );
    if ((status = UNIX_CALL( glPathTexGenNV, &args ))) WARN( "glPathTexGenNV returned %#lx\n", status );
}

static void WINAPI glPauseTransformFeedback(void)
{
    struct glPauseTransformFeedback_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPauseTransformFeedback, &args ))) WARN( "glPauseTransformFeedback returned %#lx\n", status );
}

static void WINAPI glPauseTransformFeedbackNV(void)
{
    struct glPauseTransformFeedbackNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPauseTransformFeedbackNV, &args ))) WARN( "glPauseTransformFeedbackNV returned %#lx\n", status );
}

static void WINAPI glPixelDataRangeNV( GLenum target, GLsizei length, const void *pointer )
{
    struct glPixelDataRangeNV_params args = { .teb = NtCurrentTeb(), .target = target, .length = length, .pointer = pointer };
    NTSTATUS status;
    TRACE( "target %d, length %d, pointer %p\n", target, length, pointer );
    if ((status = UNIX_CALL( glPixelDataRangeNV, &args ))) WARN( "glPixelDataRangeNV returned %#lx\n", status );
}

static void WINAPI glPixelMapx( GLenum map, GLint size, const GLfixed *values )
{
    struct glPixelMapx_params args = { .teb = NtCurrentTeb(), .map = map, .size = size, .values = values };
    NTSTATUS status;
    TRACE( "map %d, size %d, values %p\n", map, size, values );
    if ((status = UNIX_CALL( glPixelMapx, &args ))) WARN( "glPixelMapx returned %#lx\n", status );
}

static void WINAPI glPixelStorex( GLenum pname, GLfixed param )
{
    struct glPixelStorex_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glPixelStorex, &args ))) WARN( "glPixelStorex returned %#lx\n", status );
}

static void WINAPI glPixelTexGenParameterfSGIS( GLenum pname, GLfloat param )
{
    struct glPixelTexGenParameterfSGIS_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glPixelTexGenParameterfSGIS, &args ))) WARN( "glPixelTexGenParameterfSGIS returned %#lx\n", status );
}

static void WINAPI glPixelTexGenParameterfvSGIS( GLenum pname, const GLfloat *params )
{
    struct glPixelTexGenParameterfvSGIS_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPixelTexGenParameterfvSGIS, &args ))) WARN( "glPixelTexGenParameterfvSGIS returned %#lx\n", status );
}

static void WINAPI glPixelTexGenParameteriSGIS( GLenum pname, GLint param )
{
    struct glPixelTexGenParameteriSGIS_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glPixelTexGenParameteriSGIS, &args ))) WARN( "glPixelTexGenParameteriSGIS returned %#lx\n", status );
}

static void WINAPI glPixelTexGenParameterivSGIS( GLenum pname, const GLint *params )
{
    struct glPixelTexGenParameterivSGIS_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPixelTexGenParameterivSGIS, &args ))) WARN( "glPixelTexGenParameterivSGIS returned %#lx\n", status );
}

static void WINAPI glPixelTexGenSGIX( GLenum mode )
{
    struct glPixelTexGenSGIX_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glPixelTexGenSGIX, &args ))) WARN( "glPixelTexGenSGIX returned %#lx\n", status );
}

static void WINAPI glPixelTransferxOES( GLenum pname, GLfixed param )
{
    struct glPixelTransferxOES_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glPixelTransferxOES, &args ))) WARN( "glPixelTransferxOES returned %#lx\n", status );
}

static void WINAPI glPixelTransformParameterfEXT( GLenum target, GLenum pname, GLfloat param )
{
    struct glPixelTransformParameterfEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %f\n", target, pname, param );
    if ((status = UNIX_CALL( glPixelTransformParameterfEXT, &args ))) WARN( "glPixelTransformParameterfEXT returned %#lx\n", status );
}

static void WINAPI glPixelTransformParameterfvEXT( GLenum target, GLenum pname, const GLfloat *params )
{
    struct glPixelTransformParameterfvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glPixelTransformParameterfvEXT, &args ))) WARN( "glPixelTransformParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glPixelTransformParameteriEXT( GLenum target, GLenum pname, GLint param )
{
    struct glPixelTransformParameteriEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glPixelTransformParameteriEXT, &args ))) WARN( "glPixelTransformParameteriEXT returned %#lx\n", status );
}

static void WINAPI glPixelTransformParameterivEXT( GLenum target, GLenum pname, const GLint *params )
{
    struct glPixelTransformParameterivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glPixelTransformParameterivEXT, &args ))) WARN( "glPixelTransformParameterivEXT returned %#lx\n", status );
}

static void WINAPI glPixelZoomxOES( GLfixed xfactor, GLfixed yfactor )
{
    struct glPixelZoomxOES_params args = { .teb = NtCurrentTeb(), .xfactor = xfactor, .yfactor = yfactor };
    NTSTATUS status;
    TRACE( "xfactor %d, yfactor %d\n", xfactor, yfactor );
    if ((status = UNIX_CALL( glPixelZoomxOES, &args ))) WARN( "glPixelZoomxOES returned %#lx\n", status );
}

static GLboolean WINAPI glPointAlongPathNV( GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat *x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY )
{
    struct glPointAlongPathNV_params args = { .teb = NtCurrentTeb(), .path = path, .startSegment = startSegment, .numSegments = numSegments, .distance = distance, .x = x, .y = y, .tangentX = tangentX, .tangentY = tangentY };
    NTSTATUS status;
    TRACE( "path %d, startSegment %d, numSegments %d, distance %f, x %p, y %p, tangentX %p, tangentY %p\n", path, startSegment, numSegments, distance, x, y, tangentX, tangentY );
    if ((status = UNIX_CALL( glPointAlongPathNV, &args ))) WARN( "glPointAlongPathNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glPointParameterf( GLenum pname, GLfloat param )
{
    struct glPointParameterf_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glPointParameterf, &args ))) WARN( "glPointParameterf returned %#lx\n", status );
}

static void WINAPI glPointParameterfARB( GLenum pname, GLfloat param )
{
    struct glPointParameterfARB_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glPointParameterfARB, &args ))) WARN( "glPointParameterfARB returned %#lx\n", status );
}

static void WINAPI glPointParameterfEXT( GLenum pname, GLfloat param )
{
    struct glPointParameterfEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glPointParameterfEXT, &args ))) WARN( "glPointParameterfEXT returned %#lx\n", status );
}

static void WINAPI glPointParameterfSGIS( GLenum pname, GLfloat param )
{
    struct glPointParameterfSGIS_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glPointParameterfSGIS, &args ))) WARN( "glPointParameterfSGIS returned %#lx\n", status );
}

static void WINAPI glPointParameterfv( GLenum pname, const GLfloat *params )
{
    struct glPointParameterfv_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPointParameterfv, &args ))) WARN( "glPointParameterfv returned %#lx\n", status );
}

static void WINAPI glPointParameterfvARB( GLenum pname, const GLfloat *params )
{
    struct glPointParameterfvARB_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPointParameterfvARB, &args ))) WARN( "glPointParameterfvARB returned %#lx\n", status );
}

static void WINAPI glPointParameterfvEXT( GLenum pname, const GLfloat *params )
{
    struct glPointParameterfvEXT_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPointParameterfvEXT, &args ))) WARN( "glPointParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glPointParameterfvSGIS( GLenum pname, const GLfloat *params )
{
    struct glPointParameterfvSGIS_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPointParameterfvSGIS, &args ))) WARN( "glPointParameterfvSGIS returned %#lx\n", status );
}

static void WINAPI glPointParameteri( GLenum pname, GLint param )
{
    struct glPointParameteri_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glPointParameteri, &args ))) WARN( "glPointParameteri returned %#lx\n", status );
}

static void WINAPI glPointParameteriNV( GLenum pname, GLint param )
{
    struct glPointParameteriNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glPointParameteriNV, &args ))) WARN( "glPointParameteriNV returned %#lx\n", status );
}

static void WINAPI glPointParameteriv( GLenum pname, const GLint *params )
{
    struct glPointParameteriv_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPointParameteriv, &args ))) WARN( "glPointParameteriv returned %#lx\n", status );
}

static void WINAPI glPointParameterivNV( GLenum pname, const GLint *params )
{
    struct glPointParameterivNV_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPointParameterivNV, &args ))) WARN( "glPointParameterivNV returned %#lx\n", status );
}

static void WINAPI glPointParameterxvOES( GLenum pname, const GLfixed *params )
{
    struct glPointParameterxvOES_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glPointParameterxvOES, &args ))) WARN( "glPointParameterxvOES returned %#lx\n", status );
}

static void WINAPI glPointSizexOES( GLfixed size )
{
    struct glPointSizexOES_params args = { .teb = NtCurrentTeb(), .size = size };
    NTSTATUS status;
    TRACE( "size %d\n", size );
    if ((status = UNIX_CALL( glPointSizexOES, &args ))) WARN( "glPointSizexOES returned %#lx\n", status );
}

static GLint WINAPI glPollAsyncSGIX( GLuint *markerp )
{
    struct glPollAsyncSGIX_params args = { .teb = NtCurrentTeb(), .markerp = markerp };
    NTSTATUS status;
    TRACE( "markerp %p\n", markerp );
    if ((status = UNIX_CALL( glPollAsyncSGIX, &args ))) WARN( "glPollAsyncSGIX returned %#lx\n", status );
    return args.ret;
}

static GLint WINAPI glPollInstrumentsSGIX( GLint *marker_p )
{
    struct glPollInstrumentsSGIX_params args = { .teb = NtCurrentTeb(), .marker_p = marker_p };
    NTSTATUS status;
    TRACE( "marker_p %p\n", marker_p );
    if ((status = UNIX_CALL( glPollInstrumentsSGIX, &args ))) WARN( "glPollInstrumentsSGIX returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glPolygonOffsetClamp( GLfloat factor, GLfloat units, GLfloat clamp )
{
    struct glPolygonOffsetClamp_params args = { .teb = NtCurrentTeb(), .factor = factor, .units = units, .clamp = clamp };
    NTSTATUS status;
    TRACE( "factor %f, units %f, clamp %f\n", factor, units, clamp );
    if ((status = UNIX_CALL( glPolygonOffsetClamp, &args ))) WARN( "glPolygonOffsetClamp returned %#lx\n", status );
}

static void WINAPI glPolygonOffsetClampEXT( GLfloat factor, GLfloat units, GLfloat clamp )
{
    struct glPolygonOffsetClampEXT_params args = { .teb = NtCurrentTeb(), .factor = factor, .units = units, .clamp = clamp };
    NTSTATUS status;
    TRACE( "factor %f, units %f, clamp %f\n", factor, units, clamp );
    if ((status = UNIX_CALL( glPolygonOffsetClampEXT, &args ))) WARN( "glPolygonOffsetClampEXT returned %#lx\n", status );
}

static void WINAPI glPolygonOffsetEXT( GLfloat factor, GLfloat bias )
{
    struct glPolygonOffsetEXT_params args = { .teb = NtCurrentTeb(), .factor = factor, .bias = bias };
    NTSTATUS status;
    TRACE( "factor %f, bias %f\n", factor, bias );
    if ((status = UNIX_CALL( glPolygonOffsetEXT, &args ))) WARN( "glPolygonOffsetEXT returned %#lx\n", status );
}

static void WINAPI glPolygonOffsetxOES( GLfixed factor, GLfixed units )
{
    struct glPolygonOffsetxOES_params args = { .teb = NtCurrentTeb(), .factor = factor, .units = units };
    NTSTATUS status;
    TRACE( "factor %d, units %d\n", factor, units );
    if ((status = UNIX_CALL( glPolygonOffsetxOES, &args ))) WARN( "glPolygonOffsetxOES returned %#lx\n", status );
}

static void WINAPI glPopDebugGroup(void)
{
    struct glPopDebugGroup_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPopDebugGroup, &args ))) WARN( "glPopDebugGroup returned %#lx\n", status );
}

static void WINAPI glPopGroupMarkerEXT(void)
{
    struct glPopGroupMarkerEXT_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPopGroupMarkerEXT, &args ))) WARN( "glPopGroupMarkerEXT returned %#lx\n", status );
}

static void WINAPI glPresentFrameDualFillNV( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3 )
{
    struct glPresentFrameDualFillNV_params args = { .teb = NtCurrentTeb(), .video_slot = video_slot, .minPresentTime = minPresentTime, .beginPresentTimeId = beginPresentTimeId, .presentDurationId = presentDurationId, .type = type, .target0 = target0, .fill0 = fill0, .target1 = target1, .fill1 = fill1, .target2 = target2, .fill2 = fill2, .target3 = target3, .fill3 = fill3 };
    NTSTATUS status;
    TRACE( "video_slot %d, minPresentTime %s, beginPresentTimeId %d, presentDurationId %d, type %d, target0 %d, fill0 %d, target1 %d, fill1 %d, target2 %d, fill2 %d, target3 %d, fill3 %d\n", video_slot, wine_dbgstr_longlong(minPresentTime), beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3 );
    if ((status = UNIX_CALL( glPresentFrameDualFillNV, &args ))) WARN( "glPresentFrameDualFillNV returned %#lx\n", status );
}

static void WINAPI glPresentFrameKeyedNV( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1 )
{
    struct glPresentFrameKeyedNV_params args = { .teb = NtCurrentTeb(), .video_slot = video_slot, .minPresentTime = minPresentTime, .beginPresentTimeId = beginPresentTimeId, .presentDurationId = presentDurationId, .type = type, .target0 = target0, .fill0 = fill0, .key0 = key0, .target1 = target1, .fill1 = fill1, .key1 = key1 };
    NTSTATUS status;
    TRACE( "video_slot %d, minPresentTime %s, beginPresentTimeId %d, presentDurationId %d, type %d, target0 %d, fill0 %d, key0 %d, target1 %d, fill1 %d, key1 %d\n", video_slot, wine_dbgstr_longlong(minPresentTime), beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1 );
    if ((status = UNIX_CALL( glPresentFrameKeyedNV, &args ))) WARN( "glPresentFrameKeyedNV returned %#lx\n", status );
}

static void WINAPI glPrimitiveBoundingBoxARB( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW )
{
    struct glPrimitiveBoundingBoxARB_params args = { .teb = NtCurrentTeb(), .minX = minX, .minY = minY, .minZ = minZ, .minW = minW, .maxX = maxX, .maxY = maxY, .maxZ = maxZ, .maxW = maxW };
    NTSTATUS status;
    TRACE( "minX %f, minY %f, minZ %f, minW %f, maxX %f, maxY %f, maxZ %f, maxW %f\n", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW );
    if ((status = UNIX_CALL( glPrimitiveBoundingBoxARB, &args ))) WARN( "glPrimitiveBoundingBoxARB returned %#lx\n", status );
}

static void WINAPI glPrimitiveRestartIndex( GLuint index )
{
    struct glPrimitiveRestartIndex_params args = { .teb = NtCurrentTeb(), .index = index };
    NTSTATUS status;
    TRACE( "index %d\n", index );
    if ((status = UNIX_CALL( glPrimitiveRestartIndex, &args ))) WARN( "glPrimitiveRestartIndex returned %#lx\n", status );
}

static void WINAPI glPrimitiveRestartIndexNV( GLuint index )
{
    struct glPrimitiveRestartIndexNV_params args = { .teb = NtCurrentTeb(), .index = index };
    NTSTATUS status;
    TRACE( "index %d\n", index );
    if ((status = UNIX_CALL( glPrimitiveRestartIndexNV, &args ))) WARN( "glPrimitiveRestartIndexNV returned %#lx\n", status );
}

static void WINAPI glPrimitiveRestartNV(void)
{
    struct glPrimitiveRestartNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glPrimitiveRestartNV, &args ))) WARN( "glPrimitiveRestartNV returned %#lx\n", status );
}

static void WINAPI glPrioritizeTexturesEXT( GLsizei n, const GLuint *textures, const GLclampf *priorities )
{
    struct glPrioritizeTexturesEXT_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures, .priorities = priorities };
    NTSTATUS status;
    TRACE( "n %d, textures %p, priorities %p\n", n, textures, priorities );
    if ((status = UNIX_CALL( glPrioritizeTexturesEXT, &args ))) WARN( "glPrioritizeTexturesEXT returned %#lx\n", status );
}

static void WINAPI glPrioritizeTexturesxOES( GLsizei n, const GLuint *textures, const GLfixed *priorities )
{
    struct glPrioritizeTexturesxOES_params args = { .teb = NtCurrentTeb(), .n = n, .textures = textures, .priorities = priorities };
    NTSTATUS status;
    TRACE( "n %d, textures %p, priorities %p\n", n, textures, priorities );
    if ((status = UNIX_CALL( glPrioritizeTexturesxOES, &args ))) WARN( "glPrioritizeTexturesxOES returned %#lx\n", status );
}

static void WINAPI glProgramBinary( GLuint program, GLenum binaryFormat, const void *binary, GLsizei length )
{
    struct glProgramBinary_params args = { .teb = NtCurrentTeb(), .program = program, .binaryFormat = binaryFormat, .binary = binary, .length = length };
    NTSTATUS status;
    TRACE( "program %d, binaryFormat %d, binary %p, length %d\n", program, binaryFormat, binary, length );
    if ((status = UNIX_CALL( glProgramBinary, &args ))) WARN( "glProgramBinary returned %#lx\n", status );
}

static void WINAPI glProgramBufferParametersIivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint *params )
{
    struct glProgramBufferParametersIivNV_params args = { .teb = NtCurrentTeb(), .target = target, .bindingIndex = bindingIndex, .wordIndex = wordIndex, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, bindingIndex %d, wordIndex %d, count %d, params %p\n", target, bindingIndex, wordIndex, count, params );
    if ((status = UNIX_CALL( glProgramBufferParametersIivNV, &args ))) WARN( "glProgramBufferParametersIivNV returned %#lx\n", status );
}

static void WINAPI glProgramBufferParametersIuivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint *params )
{
    struct glProgramBufferParametersIuivNV_params args = { .teb = NtCurrentTeb(), .target = target, .bindingIndex = bindingIndex, .wordIndex = wordIndex, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, bindingIndex %d, wordIndex %d, count %d, params %p\n", target, bindingIndex, wordIndex, count, params );
    if ((status = UNIX_CALL( glProgramBufferParametersIuivNV, &args ))) WARN( "glProgramBufferParametersIuivNV returned %#lx\n", status );
}

static void WINAPI glProgramBufferParametersfvNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat *params )
{
    struct glProgramBufferParametersfvNV_params args = { .teb = NtCurrentTeb(), .target = target, .bindingIndex = bindingIndex, .wordIndex = wordIndex, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, bindingIndex %d, wordIndex %d, count %d, params %p\n", target, bindingIndex, wordIndex, count, params );
    if ((status = UNIX_CALL( glProgramBufferParametersfvNV, &args ))) WARN( "glProgramBufferParametersfvNV returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glProgramEnvParameter4dARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %f, y %f, z %f, w %f\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramEnvParameter4dARB, &args ))) WARN( "glProgramEnvParameter4dARB returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameter4dvARB( GLenum target, GLuint index, const GLdouble *params )
{
    struct glProgramEnvParameter4dvARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glProgramEnvParameter4dvARB, &args ))) WARN( "glProgramEnvParameter4dvARB returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glProgramEnvParameter4fARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %f, y %f, z %f, w %f\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramEnvParameter4fARB, &args ))) WARN( "glProgramEnvParameter4fARB returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameter4fvARB( GLenum target, GLuint index, const GLfloat *params )
{
    struct glProgramEnvParameter4fvARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glProgramEnvParameter4fvARB, &args ))) WARN( "glProgramEnvParameter4fvARB returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w )
{
    struct glProgramEnvParameterI4iNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %d, y %d, z %d, w %d\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramEnvParameterI4iNV, &args ))) WARN( "glProgramEnvParameterI4iNV returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameterI4ivNV( GLenum target, GLuint index, const GLint *params )
{
    struct glProgramEnvParameterI4ivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glProgramEnvParameterI4ivNV, &args ))) WARN( "glProgramEnvParameterI4ivNV returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
{
    struct glProgramEnvParameterI4uiNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %d, y %d, z %d, w %d\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramEnvParameterI4uiNV, &args ))) WARN( "glProgramEnvParameterI4uiNV returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameterI4uivNV( GLenum target, GLuint index, const GLuint *params )
{
    struct glProgramEnvParameterI4uivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glProgramEnvParameterI4uivNV, &args ))) WARN( "glProgramEnvParameterI4uivNV returned %#lx\n", status );
}

static void WINAPI glProgramEnvParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat *params )
{
    struct glProgramEnvParameters4fvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, count %d, params %p\n", target, index, count, params );
    if ((status = UNIX_CALL( glProgramEnvParameters4fvEXT, &args ))) WARN( "glProgramEnvParameters4fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramEnvParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint *params )
{
    struct glProgramEnvParametersI4ivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, count %d, params %p\n", target, index, count, params );
    if ((status = UNIX_CALL( glProgramEnvParametersI4ivNV, &args ))) WARN( "glProgramEnvParametersI4ivNV returned %#lx\n", status );
}

static void WINAPI glProgramEnvParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint *params )
{
    struct glProgramEnvParametersI4uivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, count %d, params %p\n", target, index, count, params );
    if ((status = UNIX_CALL( glProgramEnvParametersI4uivNV, &args ))) WARN( "glProgramEnvParametersI4uivNV returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glProgramLocalParameter4dARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %f, y %f, z %f, w %f\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramLocalParameter4dARB, &args ))) WARN( "glProgramLocalParameter4dARB returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameter4dvARB( GLenum target, GLuint index, const GLdouble *params )
{
    struct glProgramLocalParameter4dvARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glProgramLocalParameter4dvARB, &args ))) WARN( "glProgramLocalParameter4dvARB returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glProgramLocalParameter4fARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %f, y %f, z %f, w %f\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramLocalParameter4fARB, &args ))) WARN( "glProgramLocalParameter4fARB returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameter4fvARB( GLenum target, GLuint index, const GLfloat *params )
{
    struct glProgramLocalParameter4fvARB_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glProgramLocalParameter4fvARB, &args ))) WARN( "glProgramLocalParameter4fvARB returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w )
{
    struct glProgramLocalParameterI4iNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %d, y %d, z %d, w %d\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramLocalParameterI4iNV, &args ))) WARN( "glProgramLocalParameterI4iNV returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameterI4ivNV( GLenum target, GLuint index, const GLint *params )
{
    struct glProgramLocalParameterI4ivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glProgramLocalParameterI4ivNV, &args ))) WARN( "glProgramLocalParameterI4ivNV returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
{
    struct glProgramLocalParameterI4uiNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %d, y %d, z %d, w %d\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramLocalParameterI4uiNV, &args ))) WARN( "glProgramLocalParameterI4uiNV returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameterI4uivNV( GLenum target, GLuint index, const GLuint *params )
{
    struct glProgramLocalParameterI4uivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, params %p\n", target, index, params );
    if ((status = UNIX_CALL( glProgramLocalParameterI4uivNV, &args ))) WARN( "glProgramLocalParameterI4uivNV returned %#lx\n", status );
}

static void WINAPI glProgramLocalParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat *params )
{
    struct glProgramLocalParameters4fvEXT_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, count %d, params %p\n", target, index, count, params );
    if ((status = UNIX_CALL( glProgramLocalParameters4fvEXT, &args ))) WARN( "glProgramLocalParameters4fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramLocalParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint *params )
{
    struct glProgramLocalParametersI4ivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, count %d, params %p\n", target, index, count, params );
    if ((status = UNIX_CALL( glProgramLocalParametersI4ivNV, &args ))) WARN( "glProgramLocalParametersI4ivNV returned %#lx\n", status );
}

static void WINAPI glProgramLocalParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint *params )
{
    struct glProgramLocalParametersI4uivNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, index %d, count %d, params %p\n", target, index, count, params );
    if ((status = UNIX_CALL( glProgramLocalParametersI4uivNV, &args ))) WARN( "glProgramLocalParametersI4uivNV returned %#lx\n", status );
}

static void WINAPI glProgramNamedParameter4dNV( GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glProgramNamedParameter4dNV_params args = { .teb = NtCurrentTeb(), .id = id, .len = len, .name = name, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "id %d, len %d, name %p, x %f, y %f, z %f, w %f\n", id, len, name, x, y, z, w );
    if ((status = UNIX_CALL( glProgramNamedParameter4dNV, &args ))) WARN( "glProgramNamedParameter4dNV returned %#lx\n", status );
}

static void WINAPI glProgramNamedParameter4dvNV( GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v )
{
    struct glProgramNamedParameter4dvNV_params args = { .teb = NtCurrentTeb(), .id = id, .len = len, .name = name, .v = v };
    NTSTATUS status;
    TRACE( "id %d, len %d, name %p, v %p\n", id, len, name, v );
    if ((status = UNIX_CALL( glProgramNamedParameter4dvNV, &args ))) WARN( "glProgramNamedParameter4dvNV returned %#lx\n", status );
}

static void WINAPI glProgramNamedParameter4fNV( GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glProgramNamedParameter4fNV_params args = { .teb = NtCurrentTeb(), .id = id, .len = len, .name = name, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "id %d, len %d, name %p, x %f, y %f, z %f, w %f\n", id, len, name, x, y, z, w );
    if ((status = UNIX_CALL( glProgramNamedParameter4fNV, &args ))) WARN( "glProgramNamedParameter4fNV returned %#lx\n", status );
}

static void WINAPI glProgramNamedParameter4fvNV( GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v )
{
    struct glProgramNamedParameter4fvNV_params args = { .teb = NtCurrentTeb(), .id = id, .len = len, .name = name, .v = v };
    NTSTATUS status;
    TRACE( "id %d, len %d, name %p, v %p\n", id, len, name, v );
    if ((status = UNIX_CALL( glProgramNamedParameter4fvNV, &args ))) WARN( "glProgramNamedParameter4fvNV returned %#lx\n", status );
}

static void WINAPI glProgramParameter4dNV( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glProgramParameter4dNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %f, y %f, z %f, w %f\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramParameter4dNV, &args ))) WARN( "glProgramParameter4dNV returned %#lx\n", status );
}

static void WINAPI glProgramParameter4dvNV( GLenum target, GLuint index, const GLdouble *v )
{
    struct glProgramParameter4dvNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .v = v };
    NTSTATUS status;
    TRACE( "target %d, index %d, v %p\n", target, index, v );
    if ((status = UNIX_CALL( glProgramParameter4dvNV, &args ))) WARN( "glProgramParameter4dvNV returned %#lx\n", status );
}

static void WINAPI glProgramParameter4fNV( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glProgramParameter4fNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "target %d, index %d, x %f, y %f, z %f, w %f\n", target, index, x, y, z, w );
    if ((status = UNIX_CALL( glProgramParameter4fNV, &args ))) WARN( "glProgramParameter4fNV returned %#lx\n", status );
}

static void WINAPI glProgramParameter4fvNV( GLenum target, GLuint index, const GLfloat *v )
{
    struct glProgramParameter4fvNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .v = v };
    NTSTATUS status;
    TRACE( "target %d, index %d, v %p\n", target, index, v );
    if ((status = UNIX_CALL( glProgramParameter4fvNV, &args ))) WARN( "glProgramParameter4fvNV returned %#lx\n", status );
}

static void WINAPI glProgramParameteri( GLuint program, GLenum pname, GLint value )
{
    struct glProgramParameteri_params args = { .teb = NtCurrentTeb(), .program = program, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "program %d, pname %d, value %d\n", program, pname, value );
    if ((status = UNIX_CALL( glProgramParameteri, &args ))) WARN( "glProgramParameteri returned %#lx\n", status );
}

static void WINAPI glProgramParameteriARB( GLuint program, GLenum pname, GLint value )
{
    struct glProgramParameteriARB_params args = { .teb = NtCurrentTeb(), .program = program, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "program %d, pname %d, value %d\n", program, pname, value );
    if ((status = UNIX_CALL( glProgramParameteriARB, &args ))) WARN( "glProgramParameteriARB returned %#lx\n", status );
}

static void WINAPI glProgramParameteriEXT( GLuint program, GLenum pname, GLint value )
{
    struct glProgramParameteriEXT_params args = { .teb = NtCurrentTeb(), .program = program, .pname = pname, .value = value };
    NTSTATUS status;
    TRACE( "program %d, pname %d, value %d\n", program, pname, value );
    if ((status = UNIX_CALL( glProgramParameteriEXT, &args ))) WARN( "glProgramParameteriEXT returned %#lx\n", status );
}

static void WINAPI glProgramParameters4dvNV( GLenum target, GLuint index, GLsizei count, const GLdouble *v )
{
    struct glProgramParameters4dvNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "target %d, index %d, count %d, v %p\n", target, index, count, v );
    if ((status = UNIX_CALL( glProgramParameters4dvNV, &args ))) WARN( "glProgramParameters4dvNV returned %#lx\n", status );
}

static void WINAPI glProgramParameters4fvNV( GLenum target, GLuint index, GLsizei count, const GLfloat *v )
{
    struct glProgramParameters4fvNV_params args = { .teb = NtCurrentTeb(), .target = target, .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "target %d, index %d, count %d, v %p\n", target, index, count, v );
    if ((status = UNIX_CALL( glProgramParameters4fvNV, &args ))) WARN( "glProgramParameters4fvNV returned %#lx\n", status );
}

static void WINAPI glProgramPathFragmentInputGenNV( GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat *coeffs )
{
    struct glProgramPathFragmentInputGenNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .genMode = genMode, .components = components, .coeffs = coeffs };
    NTSTATUS status;
    TRACE( "program %d, location %d, genMode %d, components %d, coeffs %p\n", program, location, genMode, components, coeffs );
    if ((status = UNIX_CALL( glProgramPathFragmentInputGenNV, &args ))) WARN( "glProgramPathFragmentInputGenNV returned %#lx\n", status );
}

static void WINAPI glProgramStringARB( GLenum target, GLenum format, GLsizei len, const void *string )
{
    struct glProgramStringARB_params args = { .teb = NtCurrentTeb(), .target = target, .format = format, .len = len, .string = string };
    NTSTATUS status;
    TRACE( "target %d, format %d, len %d, string %p\n", target, format, len, string );
    if ((status = UNIX_CALL( glProgramStringARB, &args ))) WARN( "glProgramStringARB returned %#lx\n", status );
}

static void WINAPI glProgramSubroutineParametersuivNV( GLenum target, GLsizei count, const GLuint *params )
{
    struct glProgramSubroutineParametersuivNV_params args = { .teb = NtCurrentTeb(), .target = target, .count = count, .params = params };
    NTSTATUS status;
    TRACE( "target %d, count %d, params %p\n", target, count, params );
    if ((status = UNIX_CALL( glProgramSubroutineParametersuivNV, &args ))) WARN( "glProgramSubroutineParametersuivNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform1d( GLuint program, GLint location, GLdouble v0 )
{
    struct glProgramUniform1d_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f\n", program, location, v0 );
    if ((status = UNIX_CALL( glProgramUniform1d, &args ))) WARN( "glProgramUniform1d returned %#lx\n", status );
}

static void WINAPI glProgramUniform1dEXT( GLuint program, GLint location, GLdouble x )
{
    struct glProgramUniform1dEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %f\n", program, location, x );
    if ((status = UNIX_CALL( glProgramUniform1dEXT, &args ))) WARN( "glProgramUniform1dEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform1dv( GLuint program, GLint location, GLsizei count, const GLdouble *value )
{
    struct glProgramUniform1dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1dv, &args ))) WARN( "glProgramUniform1dv returned %#lx\n", status );
}

static void WINAPI glProgramUniform1dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value )
{
    struct glProgramUniform1dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1dvEXT, &args ))) WARN( "glProgramUniform1dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform1f( GLuint program, GLint location, GLfloat v0 )
{
    struct glProgramUniform1f_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f\n", program, location, v0 );
    if ((status = UNIX_CALL( glProgramUniform1f, &args ))) WARN( "glProgramUniform1f returned %#lx\n", status );
}

static void WINAPI glProgramUniform1fEXT( GLuint program, GLint location, GLfloat v0 )
{
    struct glProgramUniform1fEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f\n", program, location, v0 );
    if ((status = UNIX_CALL( glProgramUniform1fEXT, &args ))) WARN( "glProgramUniform1fEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform1fv( GLuint program, GLint location, GLsizei count, const GLfloat *value )
{
    struct glProgramUniform1fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1fv, &args ))) WARN( "glProgramUniform1fv returned %#lx\n", status );
}

static void WINAPI glProgramUniform1fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value )
{
    struct glProgramUniform1fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1fvEXT, &args ))) WARN( "glProgramUniform1fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform1i( GLuint program, GLint location, GLint v0 )
{
    struct glProgramUniform1i_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d\n", program, location, v0 );
    if ((status = UNIX_CALL( glProgramUniform1i, &args ))) WARN( "glProgramUniform1i returned %#lx\n", status );
}

static void WINAPI glProgramUniform1i64ARB( GLuint program, GLint location, GLint64 x )
{
    struct glProgramUniform1i64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s\n", program, location, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glProgramUniform1i64ARB, &args ))) WARN( "glProgramUniform1i64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform1i64NV( GLuint program, GLint location, GLint64EXT x )
{
    struct glProgramUniform1i64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s\n", program, location, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glProgramUniform1i64NV, &args ))) WARN( "glProgramUniform1i64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniform1i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value )
{
    struct glProgramUniform1i64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1i64vARB, &args ))) WARN( "glProgramUniform1i64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform1i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value )
{
    struct glProgramUniform1i64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1i64vNV, &args ))) WARN( "glProgramUniform1i64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform1iEXT( GLuint program, GLint location, GLint v0 )
{
    struct glProgramUniform1iEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d\n", program, location, v0 );
    if ((status = UNIX_CALL( glProgramUniform1iEXT, &args ))) WARN( "glProgramUniform1iEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform1iv( GLuint program, GLint location, GLsizei count, const GLint *value )
{
    struct glProgramUniform1iv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1iv, &args ))) WARN( "glProgramUniform1iv returned %#lx\n", status );
}

static void WINAPI glProgramUniform1ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value )
{
    struct glProgramUniform1ivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1ivEXT, &args ))) WARN( "glProgramUniform1ivEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform1ui( GLuint program, GLint location, GLuint v0 )
{
    struct glProgramUniform1ui_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d\n", program, location, v0 );
    if ((status = UNIX_CALL( glProgramUniform1ui, &args ))) WARN( "glProgramUniform1ui returned %#lx\n", status );
}

static void WINAPI glProgramUniform1ui64ARB( GLuint program, GLint location, GLuint64 x )
{
    struct glProgramUniform1ui64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s\n", program, location, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glProgramUniform1ui64ARB, &args ))) WARN( "glProgramUniform1ui64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform1ui64NV( GLuint program, GLint location, GLuint64EXT x )
{
    struct glProgramUniform1ui64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s\n", program, location, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glProgramUniform1ui64NV, &args ))) WARN( "glProgramUniform1ui64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniform1ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value )
{
    struct glProgramUniform1ui64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1ui64vARB, &args ))) WARN( "glProgramUniform1ui64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform1ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glProgramUniform1ui64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1ui64vNV, &args ))) WARN( "glProgramUniform1ui64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform1uiEXT( GLuint program, GLint location, GLuint v0 )
{
    struct glProgramUniform1uiEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d\n", program, location, v0 );
    if ((status = UNIX_CALL( glProgramUniform1uiEXT, &args ))) WARN( "glProgramUniform1uiEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform1uiv( GLuint program, GLint location, GLsizei count, const GLuint *value )
{
    struct glProgramUniform1uiv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1uiv, &args ))) WARN( "glProgramUniform1uiv returned %#lx\n", status );
}

static void WINAPI glProgramUniform1uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value )
{
    struct glProgramUniform1uivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform1uivEXT, &args ))) WARN( "glProgramUniform1uivEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform2d( GLuint program, GLint location, GLdouble v0, GLdouble v1 )
{
    struct glProgramUniform2d_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f\n", program, location, v0, v1 );
    if ((status = UNIX_CALL( glProgramUniform2d, &args ))) WARN( "glProgramUniform2d returned %#lx\n", status );
}

static void WINAPI glProgramUniform2dEXT( GLuint program, GLint location, GLdouble x, GLdouble y )
{
    struct glProgramUniform2dEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %f, y %f\n", program, location, x, y );
    if ((status = UNIX_CALL( glProgramUniform2dEXT, &args ))) WARN( "glProgramUniform2dEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform2dv( GLuint program, GLint location, GLsizei count, const GLdouble *value )
{
    struct glProgramUniform2dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2dv, &args ))) WARN( "glProgramUniform2dv returned %#lx\n", status );
}

static void WINAPI glProgramUniform2dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value )
{
    struct glProgramUniform2dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2dvEXT, &args ))) WARN( "glProgramUniform2dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform2f( GLuint program, GLint location, GLfloat v0, GLfloat v1 )
{
    struct glProgramUniform2f_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f\n", program, location, v0, v1 );
    if ((status = UNIX_CALL( glProgramUniform2f, &args ))) WARN( "glProgramUniform2f returned %#lx\n", status );
}

static void WINAPI glProgramUniform2fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1 )
{
    struct glProgramUniform2fEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f\n", program, location, v0, v1 );
    if ((status = UNIX_CALL( glProgramUniform2fEXT, &args ))) WARN( "glProgramUniform2fEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform2fv( GLuint program, GLint location, GLsizei count, const GLfloat *value )
{
    struct glProgramUniform2fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2fv, &args ))) WARN( "glProgramUniform2fv returned %#lx\n", status );
}

static void WINAPI glProgramUniform2fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value )
{
    struct glProgramUniform2fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2fvEXT, &args ))) WARN( "glProgramUniform2fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform2i( GLuint program, GLint location, GLint v0, GLint v1 )
{
    struct glProgramUniform2i_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d\n", program, location, v0, v1 );
    if ((status = UNIX_CALL( glProgramUniform2i, &args ))) WARN( "glProgramUniform2i returned %#lx\n", status );
}

static void WINAPI glProgramUniform2i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y )
{
    struct glProgramUniform2i64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glProgramUniform2i64ARB, &args ))) WARN( "glProgramUniform2i64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform2i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y )
{
    struct glProgramUniform2i64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glProgramUniform2i64NV, &args ))) WARN( "glProgramUniform2i64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniform2i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value )
{
    struct glProgramUniform2i64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2i64vARB, &args ))) WARN( "glProgramUniform2i64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform2i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value )
{
    struct glProgramUniform2i64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2i64vNV, &args ))) WARN( "glProgramUniform2i64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform2iEXT( GLuint program, GLint location, GLint v0, GLint v1 )
{
    struct glProgramUniform2iEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d\n", program, location, v0, v1 );
    if ((status = UNIX_CALL( glProgramUniform2iEXT, &args ))) WARN( "glProgramUniform2iEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform2iv( GLuint program, GLint location, GLsizei count, const GLint *value )
{
    struct glProgramUniform2iv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2iv, &args ))) WARN( "glProgramUniform2iv returned %#lx\n", status );
}

static void WINAPI glProgramUniform2ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value )
{
    struct glProgramUniform2ivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2ivEXT, &args ))) WARN( "glProgramUniform2ivEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform2ui( GLuint program, GLint location, GLuint v0, GLuint v1 )
{
    struct glProgramUniform2ui_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d\n", program, location, v0, v1 );
    if ((status = UNIX_CALL( glProgramUniform2ui, &args ))) WARN( "glProgramUniform2ui returned %#lx\n", status );
}

static void WINAPI glProgramUniform2ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y )
{
    struct glProgramUniform2ui64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glProgramUniform2ui64ARB, &args ))) WARN( "glProgramUniform2ui64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform2ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y )
{
    struct glProgramUniform2ui64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glProgramUniform2ui64NV, &args ))) WARN( "glProgramUniform2ui64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniform2ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value )
{
    struct glProgramUniform2ui64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2ui64vARB, &args ))) WARN( "glProgramUniform2ui64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform2ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glProgramUniform2ui64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2ui64vNV, &args ))) WARN( "glProgramUniform2ui64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform2uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1 )
{
    struct glProgramUniform2uiEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d\n", program, location, v0, v1 );
    if ((status = UNIX_CALL( glProgramUniform2uiEXT, &args ))) WARN( "glProgramUniform2uiEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform2uiv( GLuint program, GLint location, GLsizei count, const GLuint *value )
{
    struct glProgramUniform2uiv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2uiv, &args ))) WARN( "glProgramUniform2uiv returned %#lx\n", status );
}

static void WINAPI glProgramUniform2uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value )
{
    struct glProgramUniform2uivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform2uivEXT, &args ))) WARN( "glProgramUniform2uivEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform3d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2 )
{
    struct glProgramUniform3d_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f, v2 %f\n", program, location, v0, v1, v2 );
    if ((status = UNIX_CALL( glProgramUniform3d, &args ))) WARN( "glProgramUniform3d returned %#lx\n", status );
}

static void WINAPI glProgramUniform3dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z )
{
    struct glProgramUniform3dEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %f, y %f, z %f\n", program, location, x, y, z );
    if ((status = UNIX_CALL( glProgramUniform3dEXT, &args ))) WARN( "glProgramUniform3dEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform3dv( GLuint program, GLint location, GLsizei count, const GLdouble *value )
{
    struct glProgramUniform3dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3dv, &args ))) WARN( "glProgramUniform3dv returned %#lx\n", status );
}

static void WINAPI glProgramUniform3dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value )
{
    struct glProgramUniform3dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3dvEXT, &args ))) WARN( "glProgramUniform3dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform3f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
{
    struct glProgramUniform3f_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f, v2 %f\n", program, location, v0, v1, v2 );
    if ((status = UNIX_CALL( glProgramUniform3f, &args ))) WARN( "glProgramUniform3f returned %#lx\n", status );
}

static void WINAPI glProgramUniform3fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
{
    struct glProgramUniform3fEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f, v2 %f\n", program, location, v0, v1, v2 );
    if ((status = UNIX_CALL( glProgramUniform3fEXT, &args ))) WARN( "glProgramUniform3fEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform3fv( GLuint program, GLint location, GLsizei count, const GLfloat *value )
{
    struct glProgramUniform3fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3fv, &args ))) WARN( "glProgramUniform3fv returned %#lx\n", status );
}

static void WINAPI glProgramUniform3fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value )
{
    struct glProgramUniform3fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3fvEXT, &args ))) WARN( "glProgramUniform3fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform3i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 )
{
    struct glProgramUniform3i_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d, v2 %d\n", program, location, v0, v1, v2 );
    if ((status = UNIX_CALL( glProgramUniform3i, &args ))) WARN( "glProgramUniform3i returned %#lx\n", status );
}

static void WINAPI glProgramUniform3i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z )
{
    struct glProgramUniform3i64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s, z %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glProgramUniform3i64ARB, &args ))) WARN( "glProgramUniform3i64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform3i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z )
{
    struct glProgramUniform3i64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s, z %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glProgramUniform3i64NV, &args ))) WARN( "glProgramUniform3i64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniform3i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value )
{
    struct glProgramUniform3i64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3i64vARB, &args ))) WARN( "glProgramUniform3i64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform3i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value )
{
    struct glProgramUniform3i64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3i64vNV, &args ))) WARN( "glProgramUniform3i64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform3iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 )
{
    struct glProgramUniform3iEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d, v2 %d\n", program, location, v0, v1, v2 );
    if ((status = UNIX_CALL( glProgramUniform3iEXT, &args ))) WARN( "glProgramUniform3iEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform3iv( GLuint program, GLint location, GLsizei count, const GLint *value )
{
    struct glProgramUniform3iv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3iv, &args ))) WARN( "glProgramUniform3iv returned %#lx\n", status );
}

static void WINAPI glProgramUniform3ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value )
{
    struct glProgramUniform3ivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3ivEXT, &args ))) WARN( "glProgramUniform3ivEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform3ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 )
{
    struct glProgramUniform3ui_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d, v2 %d\n", program, location, v0, v1, v2 );
    if ((status = UNIX_CALL( glProgramUniform3ui, &args ))) WARN( "glProgramUniform3ui returned %#lx\n", status );
}

static void WINAPI glProgramUniform3ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z )
{
    struct glProgramUniform3ui64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s, z %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glProgramUniform3ui64ARB, &args ))) WARN( "glProgramUniform3ui64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform3ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z )
{
    struct glProgramUniform3ui64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s, z %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glProgramUniform3ui64NV, &args ))) WARN( "glProgramUniform3ui64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniform3ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value )
{
    struct glProgramUniform3ui64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3ui64vARB, &args ))) WARN( "glProgramUniform3ui64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform3ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glProgramUniform3ui64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3ui64vNV, &args ))) WARN( "glProgramUniform3ui64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform3uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 )
{
    struct glProgramUniform3uiEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d, v2 %d\n", program, location, v0, v1, v2 );
    if ((status = UNIX_CALL( glProgramUniform3uiEXT, &args ))) WARN( "glProgramUniform3uiEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform3uiv( GLuint program, GLint location, GLsizei count, const GLuint *value )
{
    struct glProgramUniform3uiv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3uiv, &args ))) WARN( "glProgramUniform3uiv returned %#lx\n", status );
}

static void WINAPI glProgramUniform3uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value )
{
    struct glProgramUniform3uivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform3uivEXT, &args ))) WARN( "glProgramUniform3uivEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform4d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 )
{
    struct glProgramUniform4d_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f, v2 %f, v3 %f\n", program, location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glProgramUniform4d, &args ))) WARN( "glProgramUniform4d returned %#lx\n", status );
}

static void WINAPI glProgramUniform4dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glProgramUniform4dEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %f, y %f, z %f, w %f\n", program, location, x, y, z, w );
    if ((status = UNIX_CALL( glProgramUniform4dEXT, &args ))) WARN( "glProgramUniform4dEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform4dv( GLuint program, GLint location, GLsizei count, const GLdouble *value )
{
    struct glProgramUniform4dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4dv, &args ))) WARN( "glProgramUniform4dv returned %#lx\n", status );
}

static void WINAPI glProgramUniform4dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value )
{
    struct glProgramUniform4dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4dvEXT, &args ))) WARN( "glProgramUniform4dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform4f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
{
    struct glProgramUniform4f_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f, v2 %f, v3 %f\n", program, location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glProgramUniform4f, &args ))) WARN( "glProgramUniform4f returned %#lx\n", status );
}

static void WINAPI glProgramUniform4fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
{
    struct glProgramUniform4fEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %f, v1 %f, v2 %f, v3 %f\n", program, location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glProgramUniform4fEXT, &args ))) WARN( "glProgramUniform4fEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform4fv( GLuint program, GLint location, GLsizei count, const GLfloat *value )
{
    struct glProgramUniform4fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4fv, &args ))) WARN( "glProgramUniform4fv returned %#lx\n", status );
}

static void WINAPI glProgramUniform4fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value )
{
    struct glProgramUniform4fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4fvEXT, &args ))) WARN( "glProgramUniform4fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform4i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
{
    struct glProgramUniform4i_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d, v2 %d, v3 %d\n", program, location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glProgramUniform4i, &args ))) WARN( "glProgramUniform4i returned %#lx\n", status );
}

static void WINAPI glProgramUniform4i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w )
{
    struct glProgramUniform4i64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s, z %s, w %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glProgramUniform4i64ARB, &args ))) WARN( "glProgramUniform4i64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform4i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w )
{
    struct glProgramUniform4i64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s, z %s, w %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glProgramUniform4i64NV, &args ))) WARN( "glProgramUniform4i64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniform4i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value )
{
    struct glProgramUniform4i64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4i64vARB, &args ))) WARN( "glProgramUniform4i64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform4i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value )
{
    struct glProgramUniform4i64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4i64vNV, &args ))) WARN( "glProgramUniform4i64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform4iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
{
    struct glProgramUniform4iEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d, v2 %d, v3 %d\n", program, location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glProgramUniform4iEXT, &args ))) WARN( "glProgramUniform4iEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform4iv( GLuint program, GLint location, GLsizei count, const GLint *value )
{
    struct glProgramUniform4iv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4iv, &args ))) WARN( "glProgramUniform4iv returned %#lx\n", status );
}

static void WINAPI glProgramUniform4ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value )
{
    struct glProgramUniform4ivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4ivEXT, &args ))) WARN( "glProgramUniform4ivEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform4ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
{
    struct glProgramUniform4ui_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d, v2 %d, v3 %d\n", program, location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glProgramUniform4ui, &args ))) WARN( "glProgramUniform4ui returned %#lx\n", status );
}

static void WINAPI glProgramUniform4ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w )
{
    struct glProgramUniform4ui64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s, z %s, w %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glProgramUniform4ui64ARB, &args ))) WARN( "glProgramUniform4ui64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform4ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w )
{
    struct glProgramUniform4ui64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "program %d, location %d, x %s, y %s, z %s, w %s\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glProgramUniform4ui64NV, &args ))) WARN( "glProgramUniform4ui64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniform4ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value )
{
    struct glProgramUniform4ui64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4ui64vARB, &args ))) WARN( "glProgramUniform4ui64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniform4ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glProgramUniform4ui64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4ui64vNV, &args ))) WARN( "glProgramUniform4ui64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniform4uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
{
    struct glProgramUniform4uiEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "program %d, location %d, v0 %d, v1 %d, v2 %d, v3 %d\n", program, location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glProgramUniform4uiEXT, &args ))) WARN( "glProgramUniform4uiEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniform4uiv( GLuint program, GLint location, GLsizei count, const GLuint *value )
{
    struct glProgramUniform4uiv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4uiv, &args ))) WARN( "glProgramUniform4uiv returned %#lx\n", status );
}

static void WINAPI glProgramUniform4uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value )
{
    struct glProgramUniform4uivEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniform4uivEXT, &args ))) WARN( "glProgramUniform4uivEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformHandleui64ARB( GLuint program, GLint location, GLuint64 value )
{
    struct glProgramUniformHandleui64ARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, value %s\n", program, location, wine_dbgstr_longlong(value) );
    if ((status = UNIX_CALL( glProgramUniformHandleui64ARB, &args ))) WARN( "glProgramUniformHandleui64ARB returned %#lx\n", status );
}

static void WINAPI glProgramUniformHandleui64NV( GLuint program, GLint location, GLuint64 value )
{
    struct glProgramUniformHandleui64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, value %s\n", program, location, wine_dbgstr_longlong(value) );
    if ((status = UNIX_CALL( glProgramUniformHandleui64NV, &args ))) WARN( "glProgramUniformHandleui64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniformHandleui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *values )
{
    struct glProgramUniformHandleui64vARB_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .values = values };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, values %p\n", program, location, count, values );
    if ((status = UNIX_CALL( glProgramUniformHandleui64vARB, &args ))) WARN( "glProgramUniformHandleui64vARB returned %#lx\n", status );
}

static void WINAPI glProgramUniformHandleui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64 *values )
{
    struct glProgramUniformHandleui64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .values = values };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, values %p\n", program, location, count, values );
    if ((status = UNIX_CALL( glProgramUniformHandleui64vNV, &args ))) WARN( "glProgramUniformHandleui64vNV returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix2dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2dv, &args ))) WARN( "glProgramUniformMatrix2dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix2dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2dvEXT, &args ))) WARN( "glProgramUniformMatrix2dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix2fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2fv, &args ))) WARN( "glProgramUniformMatrix2fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix2fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2fvEXT, &args ))) WARN( "glProgramUniformMatrix2fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix2x3dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2x3dv, &args ))) WARN( "glProgramUniformMatrix2x3dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix2x3dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2x3dvEXT, &args ))) WARN( "glProgramUniformMatrix2x3dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix2x3fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2x3fv, &args ))) WARN( "glProgramUniformMatrix2x3fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix2x3fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2x3fvEXT, &args ))) WARN( "glProgramUniformMatrix2x3fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix2x4dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2x4dv, &args ))) WARN( "glProgramUniformMatrix2x4dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix2x4dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2x4dvEXT, &args ))) WARN( "glProgramUniformMatrix2x4dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix2x4fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2x4fv, &args ))) WARN( "glProgramUniformMatrix2x4fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix2x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix2x4fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix2x4fvEXT, &args ))) WARN( "glProgramUniformMatrix2x4fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix3dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3dv, &args ))) WARN( "glProgramUniformMatrix3dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix3dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3dvEXT, &args ))) WARN( "glProgramUniformMatrix3dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix3fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3fv, &args ))) WARN( "glProgramUniformMatrix3fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix3fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3fvEXT, &args ))) WARN( "glProgramUniformMatrix3fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix3x2dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3x2dv, &args ))) WARN( "glProgramUniformMatrix3x2dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix3x2dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3x2dvEXT, &args ))) WARN( "glProgramUniformMatrix3x2dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix3x2fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3x2fv, &args ))) WARN( "glProgramUniformMatrix3x2fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix3x2fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3x2fvEXT, &args ))) WARN( "glProgramUniformMatrix3x2fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix3x4dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3x4dv, &args ))) WARN( "glProgramUniformMatrix3x4dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix3x4dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3x4dvEXT, &args ))) WARN( "glProgramUniformMatrix3x4dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix3x4fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3x4fv, &args ))) WARN( "glProgramUniformMatrix3x4fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix3x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix3x4fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix3x4fvEXT, &args ))) WARN( "glProgramUniformMatrix3x4fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix4dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4dv, &args ))) WARN( "glProgramUniformMatrix4dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix4dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4dvEXT, &args ))) WARN( "glProgramUniformMatrix4dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix4fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4fv, &args ))) WARN( "glProgramUniformMatrix4fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix4fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4fvEXT, &args ))) WARN( "glProgramUniformMatrix4fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix4x2dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4x2dv, &args ))) WARN( "glProgramUniformMatrix4x2dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix4x2dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4x2dvEXT, &args ))) WARN( "glProgramUniformMatrix4x2dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix4x2fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4x2fv, &args ))) WARN( "glProgramUniformMatrix4x2fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix4x2fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4x2fvEXT, &args ))) WARN( "glProgramUniformMatrix4x2fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix4x3dv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4x3dv, &args ))) WARN( "glProgramUniformMatrix4x3dv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glProgramUniformMatrix4x3dvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4x3dvEXT, &args ))) WARN( "glProgramUniformMatrix4x3dvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix4x3fv_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4x3fv, &args ))) WARN( "glProgramUniformMatrix4x3fv returned %#lx\n", status );
}

static void WINAPI glProgramUniformMatrix4x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glProgramUniformMatrix4x3fvEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, transpose %d, value %p\n", program, location, count, transpose, value );
    if ((status = UNIX_CALL( glProgramUniformMatrix4x3fvEXT, &args ))) WARN( "glProgramUniformMatrix4x3fvEXT returned %#lx\n", status );
}

static void WINAPI glProgramUniformui64NV( GLuint program, GLint location, GLuint64EXT value )
{
    struct glProgramUniformui64NV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, value %s\n", program, location, wine_dbgstr_longlong(value) );
    if ((status = UNIX_CALL( glProgramUniformui64NV, &args ))) WARN( "glProgramUniformui64NV returned %#lx\n", status );
}

static void WINAPI glProgramUniformui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glProgramUniformui64vNV_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "program %d, location %d, count %d, value %p\n", program, location, count, value );
    if ((status = UNIX_CALL( glProgramUniformui64vNV, &args ))) WARN( "glProgramUniformui64vNV returned %#lx\n", status );
}

static void WINAPI glProgramVertexLimitNV( GLenum target, GLint limit )
{
    struct glProgramVertexLimitNV_params args = { .teb = NtCurrentTeb(), .target = target, .limit = limit };
    NTSTATUS status;
    TRACE( "target %d, limit %d\n", target, limit );
    if ((status = UNIX_CALL( glProgramVertexLimitNV, &args ))) WARN( "glProgramVertexLimitNV returned %#lx\n", status );
}

static void WINAPI glProvokingVertex( GLenum mode )
{
    struct glProvokingVertex_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glProvokingVertex, &args ))) WARN( "glProvokingVertex returned %#lx\n", status );
}

static void WINAPI glProvokingVertexEXT( GLenum mode )
{
    struct glProvokingVertexEXT_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glProvokingVertexEXT, &args ))) WARN( "glProvokingVertexEXT returned %#lx\n", status );
}

static void WINAPI glPushClientAttribDefaultEXT( GLbitfield mask )
{
    struct glPushClientAttribDefaultEXT_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glPushClientAttribDefaultEXT, &args ))) WARN( "glPushClientAttribDefaultEXT returned %#lx\n", status );
}

static void WINAPI glPushDebugGroup( GLenum source, GLuint id, GLsizei length, const GLchar *message )
{
    struct glPushDebugGroup_params args = { .teb = NtCurrentTeb(), .source = source, .id = id, .length = length, .message = message };
    NTSTATUS status;
    TRACE( "source %d, id %d, length %d, message %p\n", source, id, length, message );
    if ((status = UNIX_CALL( glPushDebugGroup, &args ))) WARN( "glPushDebugGroup returned %#lx\n", status );
}

static void WINAPI glPushGroupMarkerEXT( GLsizei length, const GLchar *marker )
{
    struct glPushGroupMarkerEXT_params args = { .teb = NtCurrentTeb(), .length = length, .marker = marker };
    NTSTATUS status;
    TRACE( "length %d, marker %p\n", length, marker );
    if ((status = UNIX_CALL( glPushGroupMarkerEXT, &args ))) WARN( "glPushGroupMarkerEXT returned %#lx\n", status );
}

static void WINAPI glQueryCounter( GLuint id, GLenum target )
{
    struct glQueryCounter_params args = { .teb = NtCurrentTeb(), .id = id, .target = target };
    NTSTATUS status;
    TRACE( "id %d, target %d\n", id, target );
    if ((status = UNIX_CALL( glQueryCounter, &args ))) WARN( "glQueryCounter returned %#lx\n", status );
}

static GLbitfield WINAPI glQueryMatrixxOES( GLfixed *mantissa, GLint *exponent )
{
    struct glQueryMatrixxOES_params args = { .teb = NtCurrentTeb(), .mantissa = mantissa, .exponent = exponent };
    NTSTATUS status;
    TRACE( "mantissa %p, exponent %p\n", mantissa, exponent );
    if ((status = UNIX_CALL( glQueryMatrixxOES, &args ))) WARN( "glQueryMatrixxOES returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glQueryObjectParameteruiAMD( GLenum target, GLuint id, GLenum pname, GLuint param )
{
    struct glQueryObjectParameteruiAMD_params args = { .teb = NtCurrentTeb(), .target = target, .id = id, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, id %d, pname %d, param %d\n", target, id, pname, param );
    if ((status = UNIX_CALL( glQueryObjectParameteruiAMD, &args ))) WARN( "glQueryObjectParameteruiAMD returned %#lx\n", status );
}

static GLint WINAPI glQueryResourceNV( GLenum queryType, GLint tagId, GLuint count, GLint *buffer )
{
    struct glQueryResourceNV_params args = { .teb = NtCurrentTeb(), .queryType = queryType, .tagId = tagId, .count = count, .buffer = buffer };
    NTSTATUS status;
    TRACE( "queryType %d, tagId %d, count %d, buffer %p\n", queryType, tagId, count, buffer );
    if ((status = UNIX_CALL( glQueryResourceNV, &args ))) WARN( "glQueryResourceNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glQueryResourceTagNV( GLint tagId, const GLchar *tagString )
{
    struct glQueryResourceTagNV_params args = { .teb = NtCurrentTeb(), .tagId = tagId, .tagString = tagString };
    NTSTATUS status;
    TRACE( "tagId %d, tagString %p\n", tagId, tagString );
    if ((status = UNIX_CALL( glQueryResourceTagNV, &args ))) WARN( "glQueryResourceTagNV returned %#lx\n", status );
}

static void WINAPI glRasterPos2xOES( GLfixed x, GLfixed y )
{
    struct glRasterPos2xOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glRasterPos2xOES, &args ))) WARN( "glRasterPos2xOES returned %#lx\n", status );
}

static void WINAPI glRasterPos2xvOES( const GLfixed *coords )
{
    struct glRasterPos2xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glRasterPos2xvOES, &args ))) WARN( "glRasterPos2xvOES returned %#lx\n", status );
}

static void WINAPI glRasterPos3xOES( GLfixed x, GLfixed y, GLfixed z )
{
    struct glRasterPos3xOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glRasterPos3xOES, &args ))) WARN( "glRasterPos3xOES returned %#lx\n", status );
}

static void WINAPI glRasterPos3xvOES( const GLfixed *coords )
{
    struct glRasterPos3xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glRasterPos3xvOES, &args ))) WARN( "glRasterPos3xvOES returned %#lx\n", status );
}

static void WINAPI glRasterPos4xOES( GLfixed x, GLfixed y, GLfixed z, GLfixed w )
{
    struct glRasterPos4xOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glRasterPos4xOES, &args ))) WARN( "glRasterPos4xOES returned %#lx\n", status );
}

static void WINAPI glRasterPos4xvOES( const GLfixed *coords )
{
    struct glRasterPos4xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glRasterPos4xvOES, &args ))) WARN( "glRasterPos4xvOES returned %#lx\n", status );
}

static void WINAPI glRasterSamplesEXT( GLuint samples, GLboolean fixedsamplelocations )
{
    struct glRasterSamplesEXT_params args = { .teb = NtCurrentTeb(), .samples = samples, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "samples %d, fixedsamplelocations %d\n", samples, fixedsamplelocations );
    if ((status = UNIX_CALL( glRasterSamplesEXT, &args ))) WARN( "glRasterSamplesEXT returned %#lx\n", status );
}

static void WINAPI glReadBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glReadBufferRegion_params args = { .teb = NtCurrentTeb(), .region = region, .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "region %d, x %d, y %d, width %d, height %d\n", region, x, y, width, height );
    if ((status = UNIX_CALL( glReadBufferRegion, &args ))) WARN( "glReadBufferRegion returned %#lx\n", status );
}

static void WINAPI glReadInstrumentsSGIX( GLint marker )
{
    struct glReadInstrumentsSGIX_params args = { .teb = NtCurrentTeb(), .marker = marker };
    NTSTATUS status;
    TRACE( "marker %d\n", marker );
    if ((status = UNIX_CALL( glReadInstrumentsSGIX, &args ))) WARN( "glReadInstrumentsSGIX returned %#lx\n", status );
}

static void WINAPI glReadnPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data )
{
    struct glReadnPixels_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .width = width, .height = height, .format = format, .type = type, .bufSize = bufSize, .data = data };
    NTSTATUS status;
    TRACE( "x %d, y %d, width %d, height %d, format %d, type %d, bufSize %d, data %p\n", x, y, width, height, format, type, bufSize, data );
    if ((status = UNIX_CALL( glReadnPixels, &args ))) WARN( "glReadnPixels returned %#lx\n", status );
}

static void WINAPI glReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data )
{
    struct glReadnPixelsARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .width = width, .height = height, .format = format, .type = type, .bufSize = bufSize, .data = data };
    NTSTATUS status;
    TRACE( "x %d, y %d, width %d, height %d, format %d, type %d, bufSize %d, data %p\n", x, y, width, height, format, type, bufSize, data );
    if ((status = UNIX_CALL( glReadnPixelsARB, &args ))) WARN( "glReadnPixelsARB returned %#lx\n", status );
}

static void WINAPI glRectxOES( GLfixed x1, GLfixed y1, GLfixed x2, GLfixed y2 )
{
    struct glRectxOES_params args = { .teb = NtCurrentTeb(), .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2 };
    NTSTATUS status;
    TRACE( "x1 %d, y1 %d, x2 %d, y2 %d\n", x1, y1, x2, y2 );
    if ((status = UNIX_CALL( glRectxOES, &args ))) WARN( "glRectxOES returned %#lx\n", status );
}

static void WINAPI glRectxvOES( const GLfixed *v1, const GLfixed *v2 )
{
    struct glRectxvOES_params args = { .teb = NtCurrentTeb(), .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "v1 %p, v2 %p\n", v1, v2 );
    if ((status = UNIX_CALL( glRectxvOES, &args ))) WARN( "glRectxvOES returned %#lx\n", status );
}

static void WINAPI glReferencePlaneSGIX( const GLdouble *equation )
{
    struct glReferencePlaneSGIX_params args = { .teb = NtCurrentTeb(), .equation = equation };
    NTSTATUS status;
    TRACE( "equation %p\n", equation );
    if ((status = UNIX_CALL( glReferencePlaneSGIX, &args ))) WARN( "glReferencePlaneSGIX returned %#lx\n", status );
}

static GLboolean WINAPI glReleaseKeyedMutexWin32EXT( GLuint memory, GLuint64 key )
{
    struct glReleaseKeyedMutexWin32EXT_params args = { .teb = NtCurrentTeb(), .memory = memory, .key = key };
    NTSTATUS status;
    TRACE( "memory %d, key %s\n", memory, wine_dbgstr_longlong(key) );
    if ((status = UNIX_CALL( glReleaseKeyedMutexWin32EXT, &args ))) WARN( "glReleaseKeyedMutexWin32EXT returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glReleaseShaderCompiler(void)
{
    struct glReleaseShaderCompiler_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glReleaseShaderCompiler, &args ))) WARN( "glReleaseShaderCompiler returned %#lx\n", status );
}

static void WINAPI glRenderGpuMaskNV( GLbitfield mask )
{
    struct glRenderGpuMaskNV_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glRenderGpuMaskNV, &args ))) WARN( "glRenderGpuMaskNV returned %#lx\n", status );
}

static void WINAPI glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glRenderbufferStorage_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, height %d\n", target, internalformat, width, height );
    if ((status = UNIX_CALL( glRenderbufferStorage, &args ))) WARN( "glRenderbufferStorage returned %#lx\n", status );
}

static void WINAPI glRenderbufferStorageEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glRenderbufferStorageEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, height %d\n", target, internalformat, width, height );
    if ((status = UNIX_CALL( glRenderbufferStorageEXT, &args ))) WARN( "glRenderbufferStorageEXT returned %#lx\n", status );
}

static void WINAPI glRenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glRenderbufferStorageMultisample_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, samples %d, internalformat %d, width %d, height %d\n", target, samples, internalformat, width, height );
    if ((status = UNIX_CALL( glRenderbufferStorageMultisample, &args ))) WARN( "glRenderbufferStorageMultisample returned %#lx\n", status );
}

static void WINAPI glRenderbufferStorageMultisampleAdvancedAMD( GLenum target, GLsizei samples, GLsizei storageSamples, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glRenderbufferStorageMultisampleAdvancedAMD_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .storageSamples = storageSamples, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, samples %d, storageSamples %d, internalformat %d, width %d, height %d\n", target, samples, storageSamples, internalformat, width, height );
    if ((status = UNIX_CALL( glRenderbufferStorageMultisampleAdvancedAMD, &args ))) WARN( "glRenderbufferStorageMultisampleAdvancedAMD returned %#lx\n", status );
}

static void WINAPI glRenderbufferStorageMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glRenderbufferStorageMultisampleCoverageNV_params args = { .teb = NtCurrentTeb(), .target = target, .coverageSamples = coverageSamples, .colorSamples = colorSamples, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, coverageSamples %d, colorSamples %d, internalformat %d, width %d, height %d\n", target, coverageSamples, colorSamples, internalformat, width, height );
    if ((status = UNIX_CALL( glRenderbufferStorageMultisampleCoverageNV, &args ))) WARN( "glRenderbufferStorageMultisampleCoverageNV returned %#lx\n", status );
}

static void WINAPI glRenderbufferStorageMultisampleEXT( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glRenderbufferStorageMultisampleEXT_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, samples %d, internalformat %d, width %d, height %d\n", target, samples, internalformat, width, height );
    if ((status = UNIX_CALL( glRenderbufferStorageMultisampleEXT, &args ))) WARN( "glRenderbufferStorageMultisampleEXT returned %#lx\n", status );
}

static void WINAPI glReplacementCodePointerSUN( GLenum type, GLsizei stride, const void **pointer )
{
    struct glReplacementCodePointerSUN_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
    if ((status = UNIX_CALL( glReplacementCodePointerSUN, &args ))) WARN( "glReplacementCodePointerSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeubSUN( GLubyte code )
{
    struct glReplacementCodeubSUN_params args = { .teb = NtCurrentTeb(), .code = code };
    NTSTATUS status;
    TRACE( "code %d\n", code );
    if ((status = UNIX_CALL( glReplacementCodeubSUN, &args ))) WARN( "glReplacementCodeubSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeubvSUN( const GLubyte *code )
{
    struct glReplacementCodeubvSUN_params args = { .teb = NtCurrentTeb(), .code = code };
    NTSTATUS status;
    TRACE( "code %p\n", code );
    if ((status = UNIX_CALL( glReplacementCodeubvSUN, &args ))) WARN( "glReplacementCodeubvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiColor3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z )
{
    struct glReplacementCodeuiColor3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .r = r, .g = g, .b = b, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "rc %d, r %f, g %f, b %f, x %f, y %f, z %f\n", rc, r, g, b, x, y, z );
    if ((status = UNIX_CALL( glReplacementCodeuiColor3fVertex3fSUN, &args ))) WARN( "glReplacementCodeuiColor3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiColor3fVertex3fvSUN( const GLuint *rc, const GLfloat *c, const GLfloat *v )
{
    struct glReplacementCodeuiColor3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .c = c, .v = v };
    NTSTATUS status;
    TRACE( "rc %p, c %p, v %p\n", rc, c, v );
    if ((status = UNIX_CALL( glReplacementCodeuiColor3fVertex3fvSUN, &args ))) WARN( "glReplacementCodeuiColor3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
{
    struct glReplacementCodeuiColor4fNormal3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .r = r, .g = g, .b = b, .a = a, .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "rc %d, r %f, g %f, b %f, a %f, nx %f, ny %f, nz %f, x %f, y %f, z %f\n", rc, r, g, b, a, nx, ny, nz, x, y, z );
    if ((status = UNIX_CALL( glReplacementCodeuiColor4fNormal3fVertex3fSUN, &args ))) WARN( "glReplacementCodeuiColor4fNormal3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiColor4fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v )
{
    struct glReplacementCodeuiColor4fNormal3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .c = c, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "rc %p, c %p, n %p, v %p\n", rc, c, n, v );
    if ((status = UNIX_CALL( glReplacementCodeuiColor4fNormal3fVertex3fvSUN, &args ))) WARN( "glReplacementCodeuiColor4fNormal3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiColor4ubVertex3fSUN( GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z )
{
    struct glReplacementCodeuiColor4ubVertex3fSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .r = r, .g = g, .b = b, .a = a, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "rc %d, r %d, g %d, b %d, a %d, x %f, y %f, z %f\n", rc, r, g, b, a, x, y, z );
    if ((status = UNIX_CALL( glReplacementCodeuiColor4ubVertex3fSUN, &args ))) WARN( "glReplacementCodeuiColor4ubVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiColor4ubVertex3fvSUN( const GLuint *rc, const GLubyte *c, const GLfloat *v )
{
    struct glReplacementCodeuiColor4ubVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .c = c, .v = v };
    NTSTATUS status;
    TRACE( "rc %p, c %p, v %p\n", rc, c, v );
    if ((status = UNIX_CALL( glReplacementCodeuiColor4ubVertex3fvSUN, &args ))) WARN( "glReplacementCodeuiColor4ubVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiNormal3fVertex3fSUN( GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
{
    struct glReplacementCodeuiNormal3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "rc %d, nx %f, ny %f, nz %f, x %f, y %f, z %f\n", rc, nx, ny, nz, x, y, z );
    if ((status = UNIX_CALL( glReplacementCodeuiNormal3fVertex3fSUN, &args ))) WARN( "glReplacementCodeuiNormal3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *n, const GLfloat *v )
{
    struct glReplacementCodeuiNormal3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "rc %p, n %p, v %p\n", rc, n, v );
    if ((status = UNIX_CALL( glReplacementCodeuiNormal3fVertex3fvSUN, &args ))) WARN( "glReplacementCodeuiNormal3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiSUN( GLuint code )
{
    struct glReplacementCodeuiSUN_params args = { .teb = NtCurrentTeb(), .code = code };
    NTSTATUS status;
    TRACE( "code %d\n", code );
    if ((status = UNIX_CALL( glReplacementCodeuiSUN, &args ))) WARN( "glReplacementCodeuiSUN returned %#lx\n", status );
}

static void WINAPI 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 )
{
    struct glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .s = s, .t = t, .r = r, .g = g, .b = b, .a = a, .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "rc %d, s %f, t %f, r %f, g %f, b %f, a %f, nx %f, ny %f, nz %f, x %f, y %f, z %f\n", rc, s, t, r, g, b, a, nx, ny, nz, x, y, z );
    if ((status = UNIX_CALL( glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, &args ))) WARN( "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v )
{
    struct glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .tc = tc, .c = c, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "rc %p, tc %p, c %p, n %p, v %p\n", rc, tc, c, n, v );
    if ((status = UNIX_CALL( glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, &args ))) WARN( "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
{
    struct glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .s = s, .t = t, .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "rc %d, s %f, t %f, nx %f, ny %f, nz %f, x %f, y %f, z %f\n", rc, s, t, nx, ny, nz, x, y, z );
    if ((status = UNIX_CALL( glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, &args ))) WARN( "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v )
{
    struct glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .tc = tc, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "rc %p, tc %p, n %p, v %p\n", rc, tc, n, v );
    if ((status = UNIX_CALL( glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, &args ))) WARN( "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiTexCoord2fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z )
{
    struct glReplacementCodeuiTexCoord2fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .s = s, .t = t, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "rc %d, s %f, t %f, x %f, y %f, z %f\n", rc, s, t, x, y, z );
    if ((status = UNIX_CALL( glReplacementCodeuiTexCoord2fVertex3fSUN, &args ))) WARN( "glReplacementCodeuiTexCoord2fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiTexCoord2fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *v )
{
    struct glReplacementCodeuiTexCoord2fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .tc = tc, .v = v };
    NTSTATUS status;
    TRACE( "rc %p, tc %p, v %p\n", rc, tc, v );
    if ((status = UNIX_CALL( glReplacementCodeuiTexCoord2fVertex3fvSUN, &args ))) WARN( "glReplacementCodeuiTexCoord2fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiVertex3fSUN( GLuint rc, GLfloat x, GLfloat y, GLfloat z )
{
    struct glReplacementCodeuiVertex3fSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "rc %d, x %f, y %f, z %f\n", rc, x, y, z );
    if ((status = UNIX_CALL( glReplacementCodeuiVertex3fSUN, &args ))) WARN( "glReplacementCodeuiVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuiVertex3fvSUN( const GLuint *rc, const GLfloat *v )
{
    struct glReplacementCodeuiVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .rc = rc, .v = v };
    NTSTATUS status;
    TRACE( "rc %p, v %p\n", rc, v );
    if ((status = UNIX_CALL( glReplacementCodeuiVertex3fvSUN, &args ))) WARN( "glReplacementCodeuiVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeuivSUN( const GLuint *code )
{
    struct glReplacementCodeuivSUN_params args = { .teb = NtCurrentTeb(), .code = code };
    NTSTATUS status;
    TRACE( "code %p\n", code );
    if ((status = UNIX_CALL( glReplacementCodeuivSUN, &args ))) WARN( "glReplacementCodeuivSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeusSUN( GLushort code )
{
    struct glReplacementCodeusSUN_params args = { .teb = NtCurrentTeb(), .code = code };
    NTSTATUS status;
    TRACE( "code %d\n", code );
    if ((status = UNIX_CALL( glReplacementCodeusSUN, &args ))) WARN( "glReplacementCodeusSUN returned %#lx\n", status );
}

static void WINAPI glReplacementCodeusvSUN( const GLushort *code )
{
    struct glReplacementCodeusvSUN_params args = { .teb = NtCurrentTeb(), .code = code };
    NTSTATUS status;
    TRACE( "code %p\n", code );
    if ((status = UNIX_CALL( glReplacementCodeusvSUN, &args ))) WARN( "glReplacementCodeusvSUN returned %#lx\n", status );
}

static void WINAPI glRequestResidentProgramsNV( GLsizei n, const GLuint *programs )
{
    struct glRequestResidentProgramsNV_params args = { .teb = NtCurrentTeb(), .n = n, .programs = programs };
    NTSTATUS status;
    TRACE( "n %d, programs %p\n", n, programs );
    if ((status = UNIX_CALL( glRequestResidentProgramsNV, &args ))) WARN( "glRequestResidentProgramsNV returned %#lx\n", status );
}

static void WINAPI glResetHistogram( GLenum target )
{
    struct glResetHistogram_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glResetHistogram, &args ))) WARN( "glResetHistogram returned %#lx\n", status );
}

static void WINAPI glResetHistogramEXT( GLenum target )
{
    struct glResetHistogramEXT_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glResetHistogramEXT, &args ))) WARN( "glResetHistogramEXT returned %#lx\n", status );
}

static void WINAPI glResetMemoryObjectParameterNV( GLuint memory, GLenum pname )
{
    struct glResetMemoryObjectParameterNV_params args = { .teb = NtCurrentTeb(), .memory = memory, .pname = pname };
    NTSTATUS status;
    TRACE( "memory %d, pname %d\n", memory, pname );
    if ((status = UNIX_CALL( glResetMemoryObjectParameterNV, &args ))) WARN( "glResetMemoryObjectParameterNV returned %#lx\n", status );
}

static void WINAPI glResetMinmax( GLenum target )
{
    struct glResetMinmax_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glResetMinmax, &args ))) WARN( "glResetMinmax returned %#lx\n", status );
}

static void WINAPI glResetMinmaxEXT( GLenum target )
{
    struct glResetMinmaxEXT_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glResetMinmaxEXT, &args ))) WARN( "glResetMinmaxEXT returned %#lx\n", status );
}

static void WINAPI glResizeBuffersMESA(void)
{
    struct glResizeBuffersMESA_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glResizeBuffersMESA, &args ))) WARN( "glResizeBuffersMESA returned %#lx\n", status );
}

static void WINAPI glResolveDepthValuesNV(void)
{
    struct glResolveDepthValuesNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glResolveDepthValuesNV, &args ))) WARN( "glResolveDepthValuesNV returned %#lx\n", status );
}

static void WINAPI glResumeTransformFeedback(void)
{
    struct glResumeTransformFeedback_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glResumeTransformFeedback, &args ))) WARN( "glResumeTransformFeedback returned %#lx\n", status );
}

static void WINAPI glResumeTransformFeedbackNV(void)
{
    struct glResumeTransformFeedbackNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glResumeTransformFeedbackNV, &args ))) WARN( "glResumeTransformFeedbackNV returned %#lx\n", status );
}

static void WINAPI glRotatexOES( GLfixed angle, GLfixed x, GLfixed y, GLfixed z )
{
    struct glRotatexOES_params args = { .teb = NtCurrentTeb(), .angle = angle, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "angle %d, x %d, y %d, z %d\n", angle, x, y, z );
    if ((status = UNIX_CALL( glRotatexOES, &args ))) WARN( "glRotatexOES returned %#lx\n", status );
}

static void WINAPI glSampleCoverage( GLfloat value, GLboolean invert )
{
    struct glSampleCoverage_params args = { .teb = NtCurrentTeb(), .value = value, .invert = invert };
    NTSTATUS status;
    TRACE( "value %f, invert %d\n", value, invert );
    if ((status = UNIX_CALL( glSampleCoverage, &args ))) WARN( "glSampleCoverage returned %#lx\n", status );
}

static void WINAPI glSampleCoverageARB( GLfloat value, GLboolean invert )
{
    struct glSampleCoverageARB_params args = { .teb = NtCurrentTeb(), .value = value, .invert = invert };
    NTSTATUS status;
    TRACE( "value %f, invert %d\n", value, invert );
    if ((status = UNIX_CALL( glSampleCoverageARB, &args ))) WARN( "glSampleCoverageARB returned %#lx\n", status );
}

static void WINAPI glSampleMapATI( GLuint dst, GLuint interp, GLenum swizzle )
{
    struct glSampleMapATI_params args = { .teb = NtCurrentTeb(), .dst = dst, .interp = interp, .swizzle = swizzle };
    NTSTATUS status;
    TRACE( "dst %d, interp %d, swizzle %d\n", dst, interp, swizzle );
    if ((status = UNIX_CALL( glSampleMapATI, &args ))) WARN( "glSampleMapATI returned %#lx\n", status );
}

static void WINAPI glSampleMaskEXT( GLclampf value, GLboolean invert )
{
    struct glSampleMaskEXT_params args = { .teb = NtCurrentTeb(), .value = value, .invert = invert };
    NTSTATUS status;
    TRACE( "value %f, invert %d\n", value, invert );
    if ((status = UNIX_CALL( glSampleMaskEXT, &args ))) WARN( "glSampleMaskEXT returned %#lx\n", status );
}

static void WINAPI glSampleMaskIndexedNV( GLuint index, GLbitfield mask )
{
    struct glSampleMaskIndexedNV_params args = { .teb = NtCurrentTeb(), .index = index, .mask = mask };
    NTSTATUS status;
    TRACE( "index %d, mask %d\n", index, mask );
    if ((status = UNIX_CALL( glSampleMaskIndexedNV, &args ))) WARN( "glSampleMaskIndexedNV returned %#lx\n", status );
}

static void WINAPI glSampleMaskSGIS( GLclampf value, GLboolean invert )
{
    struct glSampleMaskSGIS_params args = { .teb = NtCurrentTeb(), .value = value, .invert = invert };
    NTSTATUS status;
    TRACE( "value %f, invert %d\n", value, invert );
    if ((status = UNIX_CALL( glSampleMaskSGIS, &args ))) WARN( "glSampleMaskSGIS returned %#lx\n", status );
}

static void WINAPI glSampleMaski( GLuint maskNumber, GLbitfield mask )
{
    struct glSampleMaski_params args = { .teb = NtCurrentTeb(), .maskNumber = maskNumber, .mask = mask };
    NTSTATUS status;
    TRACE( "maskNumber %d, mask %d\n", maskNumber, mask );
    if ((status = UNIX_CALL( glSampleMaski, &args ))) WARN( "glSampleMaski returned %#lx\n", status );
}

static void WINAPI glSamplePatternEXT( GLenum pattern )
{
    struct glSamplePatternEXT_params args = { .teb = NtCurrentTeb(), .pattern = pattern };
    NTSTATUS status;
    TRACE( "pattern %d\n", pattern );
    if ((status = UNIX_CALL( glSamplePatternEXT, &args ))) WARN( "glSamplePatternEXT returned %#lx\n", status );
}

static void WINAPI glSamplePatternSGIS( GLenum pattern )
{
    struct glSamplePatternSGIS_params args = { .teb = NtCurrentTeb(), .pattern = pattern };
    NTSTATUS status;
    TRACE( "pattern %d\n", pattern );
    if ((status = UNIX_CALL( glSamplePatternSGIS, &args ))) WARN( "glSamplePatternSGIS returned %#lx\n", status );
}

static void WINAPI glSamplerParameterIiv( GLuint sampler, GLenum pname, const GLint *param )
{
    struct glSamplerParameterIiv_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, param %p\n", sampler, pname, param );
    if ((status = UNIX_CALL( glSamplerParameterIiv, &args ))) WARN( "glSamplerParameterIiv returned %#lx\n", status );
}

static void WINAPI glSamplerParameterIuiv( GLuint sampler, GLenum pname, const GLuint *param )
{
    struct glSamplerParameterIuiv_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, param %p\n", sampler, pname, param );
    if ((status = UNIX_CALL( glSamplerParameterIuiv, &args ))) WARN( "glSamplerParameterIuiv returned %#lx\n", status );
}

static void WINAPI glSamplerParameterf( GLuint sampler, GLenum pname, GLfloat param )
{
    struct glSamplerParameterf_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, param %f\n", sampler, pname, param );
    if ((status = UNIX_CALL( glSamplerParameterf, &args ))) WARN( "glSamplerParameterf returned %#lx\n", status );
}

static void WINAPI glSamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat *param )
{
    struct glSamplerParameterfv_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, param %p\n", sampler, pname, param );
    if ((status = UNIX_CALL( glSamplerParameterfv, &args ))) WARN( "glSamplerParameterfv returned %#lx\n", status );
}

static void WINAPI glSamplerParameteri( GLuint sampler, GLenum pname, GLint param )
{
    struct glSamplerParameteri_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, param %d\n", sampler, pname, param );
    if ((status = UNIX_CALL( glSamplerParameteri, &args ))) WARN( "glSamplerParameteri returned %#lx\n", status );
}

static void WINAPI glSamplerParameteriv( GLuint sampler, GLenum pname, const GLint *param )
{
    struct glSamplerParameteriv_params args = { .teb = NtCurrentTeb(), .sampler = sampler, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "sampler %d, pname %d, param %p\n", sampler, pname, param );
    if ((status = UNIX_CALL( glSamplerParameteriv, &args ))) WARN( "glSamplerParameteriv returned %#lx\n", status );
}

static void WINAPI glScalexOES( GLfixed x, GLfixed y, GLfixed z )
{
    struct glScalexOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glScalexOES, &args ))) WARN( "glScalexOES returned %#lx\n", status );
}

static void WINAPI glScissorArrayv( GLuint first, GLsizei count, const GLint *v )
{
    struct glScissorArrayv_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "first %d, count %d, v %p\n", first, count, v );
    if ((status = UNIX_CALL( glScissorArrayv, &args ))) WARN( "glScissorArrayv returned %#lx\n", status );
}

static void WINAPI glScissorExclusiveArrayvNV( GLuint first, GLsizei count, const GLint *v )
{
    struct glScissorExclusiveArrayvNV_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "first %d, count %d, v %p\n", first, count, v );
    if ((status = UNIX_CALL( glScissorExclusiveArrayvNV, &args ))) WARN( "glScissorExclusiveArrayvNV returned %#lx\n", status );
}

static void WINAPI glScissorExclusiveNV( GLint x, GLint y, GLsizei width, GLsizei height )
{
    struct glScissorExclusiveNV_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "x %d, y %d, width %d, height %d\n", x, y, width, height );
    if ((status = UNIX_CALL( glScissorExclusiveNV, &args ))) WARN( "glScissorExclusiveNV returned %#lx\n", status );
}

static void WINAPI glScissorIndexed( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height )
{
    struct glScissorIndexed_params args = { .teb = NtCurrentTeb(), .index = index, .left = left, .bottom = bottom, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "index %d, left %d, bottom %d, width %d, height %d\n", index, left, bottom, width, height );
    if ((status = UNIX_CALL( glScissorIndexed, &args ))) WARN( "glScissorIndexed returned %#lx\n", status );
}

static void WINAPI glScissorIndexedv( GLuint index, const GLint *v )
{
    struct glScissorIndexedv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glScissorIndexedv, &args ))) WARN( "glScissorIndexedv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3b( GLbyte red, GLbyte green, GLbyte blue )
{
    struct glSecondaryColor3b_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3b, &args ))) WARN( "glSecondaryColor3b returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3bEXT( GLbyte red, GLbyte green, GLbyte blue )
{
    struct glSecondaryColor3bEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3bEXT, &args ))) WARN( "glSecondaryColor3bEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3bv( const GLbyte *v )
{
    struct glSecondaryColor3bv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3bv, &args ))) WARN( "glSecondaryColor3bv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3bvEXT( const GLbyte *v )
{
    struct glSecondaryColor3bvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3bvEXT, &args ))) WARN( "glSecondaryColor3bvEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3d( GLdouble red, GLdouble green, GLdouble blue )
{
    struct glSecondaryColor3d_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3d, &args ))) WARN( "glSecondaryColor3d returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3dEXT( GLdouble red, GLdouble green, GLdouble blue )
{
    struct glSecondaryColor3dEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3dEXT, &args ))) WARN( "glSecondaryColor3dEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3dv( const GLdouble *v )
{
    struct glSecondaryColor3dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3dv, &args ))) WARN( "glSecondaryColor3dv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3dvEXT( const GLdouble *v )
{
    struct glSecondaryColor3dvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3dvEXT, &args ))) WARN( "glSecondaryColor3dvEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3f( GLfloat red, GLfloat green, GLfloat blue )
{
    struct glSecondaryColor3f_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3f, &args ))) WARN( "glSecondaryColor3f returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue )
{
    struct glSecondaryColor3fEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %f, green %f, blue %f\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3fEXT, &args ))) WARN( "glSecondaryColor3fEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3fv( const GLfloat *v )
{
    struct glSecondaryColor3fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3fv, &args ))) WARN( "glSecondaryColor3fv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3fvEXT( const GLfloat *v )
{
    struct glSecondaryColor3fvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3fvEXT, &args ))) WARN( "glSecondaryColor3fvEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue )
{
    struct glSecondaryColor3hNV_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3hNV, &args ))) WARN( "glSecondaryColor3hNV returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3hvNV( const GLhalfNV *v )
{
    struct glSecondaryColor3hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3hvNV, &args ))) WARN( "glSecondaryColor3hvNV returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3i( GLint red, GLint green, GLint blue )
{
    struct glSecondaryColor3i_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3i, &args ))) WARN( "glSecondaryColor3i returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3iEXT( GLint red, GLint green, GLint blue )
{
    struct glSecondaryColor3iEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3iEXT, &args ))) WARN( "glSecondaryColor3iEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3iv( const GLint *v )
{
    struct glSecondaryColor3iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3iv, &args ))) WARN( "glSecondaryColor3iv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3ivEXT( const GLint *v )
{
    struct glSecondaryColor3ivEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3ivEXT, &args ))) WARN( "glSecondaryColor3ivEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3s( GLshort red, GLshort green, GLshort blue )
{
    struct glSecondaryColor3s_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3s, &args ))) WARN( "glSecondaryColor3s returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3sEXT( GLshort red, GLshort green, GLshort blue )
{
    struct glSecondaryColor3sEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3sEXT, &args ))) WARN( "glSecondaryColor3sEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3sv( const GLshort *v )
{
    struct glSecondaryColor3sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3sv, &args ))) WARN( "glSecondaryColor3sv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3svEXT( const GLshort *v )
{
    struct glSecondaryColor3svEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3svEXT, &args ))) WARN( "glSecondaryColor3svEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3ub( GLubyte red, GLubyte green, GLubyte blue )
{
    struct glSecondaryColor3ub_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3ub, &args ))) WARN( "glSecondaryColor3ub returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue )
{
    struct glSecondaryColor3ubEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3ubEXT, &args ))) WARN( "glSecondaryColor3ubEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3ubv( const GLubyte *v )
{
    struct glSecondaryColor3ubv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3ubv, &args ))) WARN( "glSecondaryColor3ubv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3ubvEXT( const GLubyte *v )
{
    struct glSecondaryColor3ubvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3ubvEXT, &args ))) WARN( "glSecondaryColor3ubvEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3ui( GLuint red, GLuint green, GLuint blue )
{
    struct glSecondaryColor3ui_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3ui, &args ))) WARN( "glSecondaryColor3ui returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3uiEXT( GLuint red, GLuint green, GLuint blue )
{
    struct glSecondaryColor3uiEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3uiEXT, &args ))) WARN( "glSecondaryColor3uiEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3uiv( const GLuint *v )
{
    struct glSecondaryColor3uiv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3uiv, &args ))) WARN( "glSecondaryColor3uiv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3uivEXT( const GLuint *v )
{
    struct glSecondaryColor3uivEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3uivEXT, &args ))) WARN( "glSecondaryColor3uivEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3us( GLushort red, GLushort green, GLushort blue )
{
    struct glSecondaryColor3us_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3us, &args ))) WARN( "glSecondaryColor3us returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3usEXT( GLushort red, GLushort green, GLushort blue )
{
    struct glSecondaryColor3usEXT_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
    if ((status = UNIX_CALL( glSecondaryColor3usEXT, &args ))) WARN( "glSecondaryColor3usEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3usv( const GLushort *v )
{
    struct glSecondaryColor3usv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3usv, &args ))) WARN( "glSecondaryColor3usv returned %#lx\n", status );
}

static void WINAPI glSecondaryColor3usvEXT( const GLushort *v )
{
    struct glSecondaryColor3usvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glSecondaryColor3usvEXT, &args ))) WARN( "glSecondaryColor3usvEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColorFormatNV( GLint size, GLenum type, GLsizei stride )
{
    struct glSecondaryColorFormatNV_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d\n", size, type, stride );
    if ((status = UNIX_CALL( glSecondaryColorFormatNV, &args ))) WARN( "glSecondaryColorFormatNV returned %#lx\n", status );
}

static void WINAPI glSecondaryColorP3ui( GLenum type, GLuint color )
{
    struct glSecondaryColorP3ui_params args = { .teb = NtCurrentTeb(), .type = type, .color = color };
    NTSTATUS status;
    TRACE( "type %d, color %d\n", type, color );
    if ((status = UNIX_CALL( glSecondaryColorP3ui, &args ))) WARN( "glSecondaryColorP3ui returned %#lx\n", status );
}

static void WINAPI glSecondaryColorP3uiv( GLenum type, const GLuint *color )
{
    struct glSecondaryColorP3uiv_params args = { .teb = NtCurrentTeb(), .type = type, .color = color };
    NTSTATUS status;
    TRACE( "type %d, color %p\n", type, color );
    if ((status = UNIX_CALL( glSecondaryColorP3uiv, &args ))) WARN( "glSecondaryColorP3uiv returned %#lx\n", status );
}

static void WINAPI glSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glSecondaryColorPointer_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
    if ((status = UNIX_CALL( glSecondaryColorPointer, &args ))) WARN( "glSecondaryColorPointer returned %#lx\n", status );
}

static void WINAPI glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glSecondaryColorPointerEXT_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
    if ((status = UNIX_CALL( glSecondaryColorPointerEXT, &args ))) WARN( "glSecondaryColorPointerEXT returned %#lx\n", status );
}

static void WINAPI glSecondaryColorPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride )
{
    struct glSecondaryColorPointerListIBM_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer, .ptrstride = ptrstride };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p, ptrstride %d\n", size, type, stride, pointer, ptrstride );
    if ((status = UNIX_CALL( glSecondaryColorPointerListIBM, &args ))) WARN( "glSecondaryColorPointerListIBM returned %#lx\n", status );
}

static void WINAPI glSelectPerfMonitorCountersAMD( GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *counterList )
{
    struct glSelectPerfMonitorCountersAMD_params args = { .teb = NtCurrentTeb(), .monitor = monitor, .enable = enable, .group = group, .numCounters = numCounters, .counterList = counterList };
    NTSTATUS status;
    TRACE( "monitor %d, enable %d, group %d, numCounters %d, counterList %p\n", monitor, enable, group, numCounters, counterList );
    if ((status = UNIX_CALL( glSelectPerfMonitorCountersAMD, &args ))) WARN( "glSelectPerfMonitorCountersAMD returned %#lx\n", status );
}

static void WINAPI glSelectTextureCoordSetSGIS( GLenum target )
{
    struct glSelectTextureCoordSetSGIS_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glSelectTextureCoordSetSGIS, &args ))) WARN( "glSelectTextureCoordSetSGIS returned %#lx\n", status );
}

static void WINAPI glSelectTextureSGIS( GLenum target )
{
    struct glSelectTextureSGIS_params args = { .teb = NtCurrentTeb(), .target = target };
    NTSTATUS status;
    TRACE( "target %d\n", target );
    if ((status = UNIX_CALL( glSelectTextureSGIS, &args ))) WARN( "glSelectTextureSGIS returned %#lx\n", status );
}

static void WINAPI glSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, const GLuint64 *params )
{
    struct glSemaphoreParameterui64vEXT_params args = { .teb = NtCurrentTeb(), .semaphore = semaphore, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "semaphore %d, pname %d, params %p\n", semaphore, pname, params );
    if ((status = UNIX_CALL( glSemaphoreParameterui64vEXT, &args ))) WARN( "glSemaphoreParameterui64vEXT returned %#lx\n", status );
}

static void WINAPI glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column )
{
    struct glSeparableFilter2D_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .height = height, .format = format, .type = type, .row = row, .column = column };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, height %d, format %d, type %d, row %p, column %p\n", target, internalformat, width, height, format, type, row, column );
    if ((status = UNIX_CALL( glSeparableFilter2D, &args ))) WARN( "glSeparableFilter2D returned %#lx\n", status );
}

static void WINAPI glSeparableFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column )
{
    struct glSeparableFilter2DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .width = width, .height = height, .format = format, .type = type, .row = row, .column = column };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, width %d, height %d, format %d, type %d, row %p, column %p\n", target, internalformat, width, height, format, type, row, column );
    if ((status = UNIX_CALL( glSeparableFilter2DEXT, &args ))) WARN( "glSeparableFilter2DEXT returned %#lx\n", status );
}

static void WINAPI glSetFenceAPPLE( GLuint fence )
{
    struct glSetFenceAPPLE_params args = { .teb = NtCurrentTeb(), .fence = fence };
    NTSTATUS status;
    TRACE( "fence %d\n", fence );
    if ((status = UNIX_CALL( glSetFenceAPPLE, &args ))) WARN( "glSetFenceAPPLE returned %#lx\n", status );
}

static void WINAPI glSetFenceNV( GLuint fence, GLenum condition )
{
    struct glSetFenceNV_params args = { .teb = NtCurrentTeb(), .fence = fence, .condition = condition };
    NTSTATUS status;
    TRACE( "fence %d, condition %d\n", fence, condition );
    if ((status = UNIX_CALL( glSetFenceNV, &args ))) WARN( "glSetFenceNV returned %#lx\n", status );
}

static void WINAPI glSetFragmentShaderConstantATI( GLuint dst, const GLfloat *value )
{
    struct glSetFragmentShaderConstantATI_params args = { .teb = NtCurrentTeb(), .dst = dst, .value = value };
    NTSTATUS status;
    TRACE( "dst %d, value %p\n", dst, value );
    if ((status = UNIX_CALL( glSetFragmentShaderConstantATI, &args ))) WARN( "glSetFragmentShaderConstantATI returned %#lx\n", status );
}

static void WINAPI glSetInvariantEXT( GLuint id, GLenum type, const void *addr )
{
    struct glSetInvariantEXT_params args = { .teb = NtCurrentTeb(), .id = id, .type = type, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, type %d, addr %p\n", id, type, addr );
    if ((status = UNIX_CALL( glSetInvariantEXT, &args ))) WARN( "glSetInvariantEXT returned %#lx\n", status );
}

static void WINAPI glSetLocalConstantEXT( GLuint id, GLenum type, const void *addr )
{
    struct glSetLocalConstantEXT_params args = { .teb = NtCurrentTeb(), .id = id, .type = type, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, type %d, addr %p\n", id, type, addr );
    if ((status = UNIX_CALL( glSetLocalConstantEXT, &args ))) WARN( "glSetLocalConstantEXT returned %#lx\n", status );
}

static void WINAPI glSetMultisamplefvAMD( GLenum pname, GLuint index, const GLfloat *val )
{
    struct glSetMultisamplefvAMD_params args = { .teb = NtCurrentTeb(), .pname = pname, .index = index, .val = val };
    NTSTATUS status;
    TRACE( "pname %d, index %d, val %p\n", pname, index, val );
    if ((status = UNIX_CALL( glSetMultisamplefvAMD, &args ))) WARN( "glSetMultisamplefvAMD returned %#lx\n", status );
}

static void WINAPI glShaderBinary( GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length )
{
    struct glShaderBinary_params args = { .teb = NtCurrentTeb(), .count = count, .shaders = shaders, .binaryformat = binaryformat, .binary = binary, .length = length };
    NTSTATUS status;
    TRACE( "count %d, shaders %p, binaryformat %d, binary %p, length %d\n", count, shaders, binaryformat, binary, length );
    if ((status = UNIX_CALL( glShaderBinary, &args ))) WARN( "glShaderBinary returned %#lx\n", status );
}

static void WINAPI glShaderOp1EXT( GLenum op, GLuint res, GLuint arg1 )
{
    struct glShaderOp1EXT_params args = { .teb = NtCurrentTeb(), .op = op, .res = res, .arg1 = arg1 };
    NTSTATUS status;
    TRACE( "op %d, res %d, arg1 %d\n", op, res, arg1 );
    if ((status = UNIX_CALL( glShaderOp1EXT, &args ))) WARN( "glShaderOp1EXT returned %#lx\n", status );
}

static void WINAPI glShaderOp2EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2 )
{
    struct glShaderOp2EXT_params args = { .teb = NtCurrentTeb(), .op = op, .res = res, .arg1 = arg1, .arg2 = arg2 };
    NTSTATUS status;
    TRACE( "op %d, res %d, arg1 %d, arg2 %d\n", op, res, arg1, arg2 );
    if ((status = UNIX_CALL( glShaderOp2EXT, &args ))) WARN( "glShaderOp2EXT returned %#lx\n", status );
}

static void WINAPI glShaderOp3EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3 )
{
    struct glShaderOp3EXT_params args = { .teb = NtCurrentTeb(), .op = op, .res = res, .arg1 = arg1, .arg2 = arg2, .arg3 = arg3 };
    NTSTATUS status;
    TRACE( "op %d, res %d, arg1 %d, arg2 %d, arg3 %d\n", op, res, arg1, arg2, arg3 );
    if ((status = UNIX_CALL( glShaderOp3EXT, &args ))) WARN( "glShaderOp3EXT returned %#lx\n", status );
}

static void WINAPI glShaderSource( GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length )
{
    struct glShaderSource_params args = { .teb = NtCurrentTeb(), .shader = shader, .count = count, .string = string, .length = length };
    NTSTATUS status;
    TRACE( "shader %d, count %d, string %p, length %p\n", shader, count, string, length );
    if ((status = UNIX_CALL( glShaderSource, &args ))) WARN( "glShaderSource returned %#lx\n", status );
}

static void WINAPI glShaderSourceARB( GLhandleARB shaderObj, GLsizei count, const GLcharARB **string, const GLint *length )
{
    struct glShaderSourceARB_params args = { .teb = NtCurrentTeb(), .shaderObj = shaderObj, .count = count, .string = string, .length = length };
    NTSTATUS status;
    TRACE( "shaderObj %d, count %d, string %p, length %p\n", shaderObj, count, string, length );
    if ((status = UNIX_CALL( glShaderSourceARB, &args ))) WARN( "glShaderSourceARB returned %#lx\n", status );
}

static void WINAPI glShaderStorageBlockBinding( GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding )
{
    struct glShaderStorageBlockBinding_params args = { .teb = NtCurrentTeb(), .program = program, .storageBlockIndex = storageBlockIndex, .storageBlockBinding = storageBlockBinding };
    NTSTATUS status;
    TRACE( "program %d, storageBlockIndex %d, storageBlockBinding %d\n", program, storageBlockIndex, storageBlockBinding );
    if ((status = UNIX_CALL( glShaderStorageBlockBinding, &args ))) WARN( "glShaderStorageBlockBinding returned %#lx\n", status );
}

static void WINAPI glShadingRateImageBarrierNV( GLboolean synchronize )
{
    struct glShadingRateImageBarrierNV_params args = { .teb = NtCurrentTeb(), .synchronize = synchronize };
    NTSTATUS status;
    TRACE( "synchronize %d\n", synchronize );
    if ((status = UNIX_CALL( glShadingRateImageBarrierNV, &args ))) WARN( "glShadingRateImageBarrierNV returned %#lx\n", status );
}

static void WINAPI glShadingRateImagePaletteNV( GLuint viewport, GLuint first, GLsizei count, const GLenum *rates )
{
    struct glShadingRateImagePaletteNV_params args = { .teb = NtCurrentTeb(), .viewport = viewport, .first = first, .count = count, .rates = rates };
    NTSTATUS status;
    TRACE( "viewport %d, first %d, count %d, rates %p\n", viewport, first, count, rates );
    if ((status = UNIX_CALL( glShadingRateImagePaletteNV, &args ))) WARN( "glShadingRateImagePaletteNV returned %#lx\n", status );
}

static void WINAPI glShadingRateSampleOrderCustomNV( GLenum rate, GLuint samples, const GLint *locations )
{
    struct glShadingRateSampleOrderCustomNV_params args = { .teb = NtCurrentTeb(), .rate = rate, .samples = samples, .locations = locations };
    NTSTATUS status;
    TRACE( "rate %d, samples %d, locations %p\n", rate, samples, locations );
    if ((status = UNIX_CALL( glShadingRateSampleOrderCustomNV, &args ))) WARN( "glShadingRateSampleOrderCustomNV returned %#lx\n", status );
}

static void WINAPI glShadingRateSampleOrderNV( GLenum order )
{
    struct glShadingRateSampleOrderNV_params args = { .teb = NtCurrentTeb(), .order = order };
    NTSTATUS status;
    TRACE( "order %d\n", order );
    if ((status = UNIX_CALL( glShadingRateSampleOrderNV, &args ))) WARN( "glShadingRateSampleOrderNV returned %#lx\n", status );
}

static void WINAPI glSharpenTexFuncSGIS( GLenum target, GLsizei n, const GLfloat *points )
{
    struct glSharpenTexFuncSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .n = n, .points = points };
    NTSTATUS status;
    TRACE( "target %d, n %d, points %p\n", target, n, points );
    if ((status = UNIX_CALL( glSharpenTexFuncSGIS, &args ))) WARN( "glSharpenTexFuncSGIS returned %#lx\n", status );
}

static void WINAPI glSignalSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *dstLayouts )
{
    struct glSignalSemaphoreEXT_params args = { .teb = NtCurrentTeb(), .semaphore = semaphore, .numBufferBarriers = numBufferBarriers, .buffers = buffers, .numTextureBarriers = numTextureBarriers, .textures = textures, .dstLayouts = dstLayouts };
    NTSTATUS status;
    TRACE( "semaphore %d, numBufferBarriers %d, buffers %p, numTextureBarriers %d, textures %p, dstLayouts %p\n", semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts );
    if ((status = UNIX_CALL( glSignalSemaphoreEXT, &args ))) WARN( "glSignalSemaphoreEXT returned %#lx\n", status );
}

static void WINAPI glSignalSemaphoreui64NVX( GLuint signalGpu, GLsizei fenceObjectCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray )
{
    struct glSignalSemaphoreui64NVX_params args = { .teb = NtCurrentTeb(), .signalGpu = signalGpu, .fenceObjectCount = fenceObjectCount, .semaphoreArray = semaphoreArray, .fenceValueArray = fenceValueArray };
    NTSTATUS status;
    TRACE( "signalGpu %d, fenceObjectCount %d, semaphoreArray %p, fenceValueArray %p\n", signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray );
    if ((status = UNIX_CALL( glSignalSemaphoreui64NVX, &args ))) WARN( "glSignalSemaphoreui64NVX returned %#lx\n", status );
}

static void WINAPI glSignalVkFenceNV( GLuint64 vkFence )
{
    struct glSignalVkFenceNV_params args = { .teb = NtCurrentTeb(), .vkFence = vkFence };
    NTSTATUS status;
    TRACE( "vkFence %s\n", wine_dbgstr_longlong(vkFence) );
    if ((status = UNIX_CALL( glSignalVkFenceNV, &args ))) WARN( "glSignalVkFenceNV returned %#lx\n", status );
}

static void WINAPI glSignalVkSemaphoreNV( GLuint64 vkSemaphore )
{
    struct glSignalVkSemaphoreNV_params args = { .teb = NtCurrentTeb(), .vkSemaphore = vkSemaphore };
    NTSTATUS status;
    TRACE( "vkSemaphore %s\n", wine_dbgstr_longlong(vkSemaphore) );
    if ((status = UNIX_CALL( glSignalVkSemaphoreNV, &args ))) WARN( "glSignalVkSemaphoreNV returned %#lx\n", status );
}

static void WINAPI glSpecializeShader( GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue )
{
    struct glSpecializeShader_params args = { .teb = NtCurrentTeb(), .shader = shader, .pEntryPoint = pEntryPoint, .numSpecializationConstants = numSpecializationConstants, .pConstantIndex = pConstantIndex, .pConstantValue = pConstantValue };
    NTSTATUS status;
    TRACE( "shader %d, pEntryPoint %p, numSpecializationConstants %d, pConstantIndex %p, pConstantValue %p\n", shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue );
    if ((status = UNIX_CALL( glSpecializeShader, &args ))) WARN( "glSpecializeShader returned %#lx\n", status );
}

static void WINAPI glSpecializeShaderARB( GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue )
{
    struct glSpecializeShaderARB_params args = { .teb = NtCurrentTeb(), .shader = shader, .pEntryPoint = pEntryPoint, .numSpecializationConstants = numSpecializationConstants, .pConstantIndex = pConstantIndex, .pConstantValue = pConstantValue };
    NTSTATUS status;
    TRACE( "shader %d, pEntryPoint %p, numSpecializationConstants %d, pConstantIndex %p, pConstantValue %p\n", shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue );
    if ((status = UNIX_CALL( glSpecializeShaderARB, &args ))) WARN( "glSpecializeShaderARB returned %#lx\n", status );
}

static void WINAPI glSpriteParameterfSGIX( GLenum pname, GLfloat param )
{
    struct glSpriteParameterfSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glSpriteParameterfSGIX, &args ))) WARN( "glSpriteParameterfSGIX returned %#lx\n", status );
}

static void WINAPI glSpriteParameterfvSGIX( GLenum pname, const GLfloat *params )
{
    struct glSpriteParameterfvSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glSpriteParameterfvSGIX, &args ))) WARN( "glSpriteParameterfvSGIX returned %#lx\n", status );
}

static void WINAPI glSpriteParameteriSGIX( GLenum pname, GLint param )
{
    struct glSpriteParameteriSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glSpriteParameteriSGIX, &args ))) WARN( "glSpriteParameteriSGIX returned %#lx\n", status );
}

static void WINAPI glSpriteParameterivSGIX( GLenum pname, const GLint *params )
{
    struct glSpriteParameterivSGIX_params args = { .teb = NtCurrentTeb(), .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "pname %d, params %p\n", pname, params );
    if ((status = UNIX_CALL( glSpriteParameterivSGIX, &args ))) WARN( "glSpriteParameterivSGIX returned %#lx\n", status );
}

static void WINAPI glStartInstrumentsSGIX(void)
{
    struct glStartInstrumentsSGIX_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glStartInstrumentsSGIX, &args ))) WARN( "glStartInstrumentsSGIX returned %#lx\n", status );
}

static void WINAPI glStateCaptureNV( GLuint state, GLenum mode )
{
    struct glStateCaptureNV_params args = { .teb = NtCurrentTeb(), .state = state, .mode = mode };
    NTSTATUS status;
    TRACE( "state %d, mode %d\n", state, mode );
    if ((status = UNIX_CALL( glStateCaptureNV, &args ))) WARN( "glStateCaptureNV returned %#lx\n", status );
}

static void WINAPI glStencilClearTagEXT( GLsizei stencilTagBits, GLuint stencilClearTag )
{
    struct glStencilClearTagEXT_params args = { .teb = NtCurrentTeb(), .stencilTagBits = stencilTagBits, .stencilClearTag = stencilClearTag };
    NTSTATUS status;
    TRACE( "stencilTagBits %d, stencilClearTag %d\n", stencilTagBits, stencilClearTag );
    if ((status = UNIX_CALL( glStencilClearTagEXT, &args ))) WARN( "glStencilClearTagEXT returned %#lx\n", status );
}

static void WINAPI glStencilFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues )
{
    struct glStencilFillPathInstancedNV_params args = { .teb = NtCurrentTeb(), .numPaths = numPaths, .pathNameType = pathNameType, .paths = paths, .pathBase = pathBase, .fillMode = fillMode, .mask = mask, .transformType = transformType, .transformValues = transformValues };
    NTSTATUS status;
    TRACE( "numPaths %d, pathNameType %d, paths %p, pathBase %d, fillMode %d, mask %d, transformType %d, transformValues %p\n", numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues );
    if ((status = UNIX_CALL( glStencilFillPathInstancedNV, &args ))) WARN( "glStencilFillPathInstancedNV returned %#lx\n", status );
}

static void WINAPI glStencilFillPathNV( GLuint path, GLenum fillMode, GLuint mask )
{
    struct glStencilFillPathNV_params args = { .teb = NtCurrentTeb(), .path = path, .fillMode = fillMode, .mask = mask };
    NTSTATUS status;
    TRACE( "path %d, fillMode %d, mask %d\n", path, fillMode, mask );
    if ((status = UNIX_CALL( glStencilFillPathNV, &args ))) WARN( "glStencilFillPathNV returned %#lx\n", status );
}

static void WINAPI glStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask )
{
    struct glStencilFuncSeparate_params args = { .teb = NtCurrentTeb(), .face = face, .func = func, .ref = ref, .mask = mask };
    NTSTATUS status;
    TRACE( "face %d, func %d, ref %d, mask %d\n", face, func, ref, mask );
    if ((status = UNIX_CALL( glStencilFuncSeparate, &args ))) WARN( "glStencilFuncSeparate returned %#lx\n", status );
}

static void WINAPI glStencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask )
{
    struct glStencilFuncSeparateATI_params args = { .teb = NtCurrentTeb(), .frontfunc = frontfunc, .backfunc = backfunc, .ref = ref, .mask = mask };
    NTSTATUS status;
    TRACE( "frontfunc %d, backfunc %d, ref %d, mask %d\n", frontfunc, backfunc, ref, mask );
    if ((status = UNIX_CALL( glStencilFuncSeparateATI, &args ))) WARN( "glStencilFuncSeparateATI returned %#lx\n", status );
}

static void WINAPI glStencilMaskSeparate( GLenum face, GLuint mask )
{
    struct glStencilMaskSeparate_params args = { .teb = NtCurrentTeb(), .face = face, .mask = mask };
    NTSTATUS status;
    TRACE( "face %d, mask %d\n", face, mask );
    if ((status = UNIX_CALL( glStencilMaskSeparate, &args ))) WARN( "glStencilMaskSeparate returned %#lx\n", status );
}

static void WINAPI glStencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass )
{
    struct glStencilOpSeparate_params args = { .teb = NtCurrentTeb(), .face = face, .sfail = sfail, .dpfail = dpfail, .dppass = dppass };
    NTSTATUS status;
    TRACE( "face %d, sfail %d, dpfail %d, dppass %d\n", face, sfail, dpfail, dppass );
    if ((status = UNIX_CALL( glStencilOpSeparate, &args ))) WARN( "glStencilOpSeparate returned %#lx\n", status );
}

static void WINAPI glStencilOpSeparateATI( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass )
{
    struct glStencilOpSeparateATI_params args = { .teb = NtCurrentTeb(), .face = face, .sfail = sfail, .dpfail = dpfail, .dppass = dppass };
    NTSTATUS status;
    TRACE( "face %d, sfail %d, dpfail %d, dppass %d\n", face, sfail, dpfail, dppass );
    if ((status = UNIX_CALL( glStencilOpSeparateATI, &args ))) WARN( "glStencilOpSeparateATI returned %#lx\n", status );
}

static void WINAPI glStencilOpValueAMD( GLenum face, GLuint value )
{
    struct glStencilOpValueAMD_params args = { .teb = NtCurrentTeb(), .face = face, .value = value };
    NTSTATUS status;
    TRACE( "face %d, value %d\n", face, value );
    if ((status = UNIX_CALL( glStencilOpValueAMD, &args ))) WARN( "glStencilOpValueAMD returned %#lx\n", status );
}

static void WINAPI glStencilStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues )
{
    struct glStencilStrokePathInstancedNV_params args = { .teb = NtCurrentTeb(), .numPaths = numPaths, .pathNameType = pathNameType, .paths = paths, .pathBase = pathBase, .reference = reference, .mask = mask, .transformType = transformType, .transformValues = transformValues };
    NTSTATUS status;
    TRACE( "numPaths %d, pathNameType %d, paths %p, pathBase %d, reference %d, mask %d, transformType %d, transformValues %p\n", numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues );
    if ((status = UNIX_CALL( glStencilStrokePathInstancedNV, &args ))) WARN( "glStencilStrokePathInstancedNV returned %#lx\n", status );
}

static void WINAPI glStencilStrokePathNV( GLuint path, GLint reference, GLuint mask )
{
    struct glStencilStrokePathNV_params args = { .teb = NtCurrentTeb(), .path = path, .reference = reference, .mask = mask };
    NTSTATUS status;
    TRACE( "path %d, reference %d, mask %d\n", path, reference, mask );
    if ((status = UNIX_CALL( glStencilStrokePathNV, &args ))) WARN( "glStencilStrokePathNV returned %#lx\n", status );
}

static void WINAPI glStencilThenCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues )
{
    struct glStencilThenCoverFillPathInstancedNV_params args = { .teb = NtCurrentTeb(), .numPaths = numPaths, .pathNameType = pathNameType, .paths = paths, .pathBase = pathBase, .fillMode = fillMode, .mask = mask, .coverMode = coverMode, .transformType = transformType, .transformValues = transformValues };
    NTSTATUS status;
    TRACE( "numPaths %d, pathNameType %d, paths %p, pathBase %d, fillMode %d, mask %d, coverMode %d, transformType %d, transformValues %p\n", numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues );
    if ((status = UNIX_CALL( glStencilThenCoverFillPathInstancedNV, &args ))) WARN( "glStencilThenCoverFillPathInstancedNV returned %#lx\n", status );
}

static void WINAPI glStencilThenCoverFillPathNV( GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode )
{
    struct glStencilThenCoverFillPathNV_params args = { .teb = NtCurrentTeb(), .path = path, .fillMode = fillMode, .mask = mask, .coverMode = coverMode };
    NTSTATUS status;
    TRACE( "path %d, fillMode %d, mask %d, coverMode %d\n", path, fillMode, mask, coverMode );
    if ((status = UNIX_CALL( glStencilThenCoverFillPathNV, &args ))) WARN( "glStencilThenCoverFillPathNV returned %#lx\n", status );
}

static void WINAPI glStencilThenCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues )
{
    struct glStencilThenCoverStrokePathInstancedNV_params args = { .teb = NtCurrentTeb(), .numPaths = numPaths, .pathNameType = pathNameType, .paths = paths, .pathBase = pathBase, .reference = reference, .mask = mask, .coverMode = coverMode, .transformType = transformType, .transformValues = transformValues };
    NTSTATUS status;
    TRACE( "numPaths %d, pathNameType %d, paths %p, pathBase %d, reference %d, mask %d, coverMode %d, transformType %d, transformValues %p\n", numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues );
    if ((status = UNIX_CALL( glStencilThenCoverStrokePathInstancedNV, &args ))) WARN( "glStencilThenCoverStrokePathInstancedNV returned %#lx\n", status );
}

static void WINAPI glStencilThenCoverStrokePathNV( GLuint path, GLint reference, GLuint mask, GLenum coverMode )
{
    struct glStencilThenCoverStrokePathNV_params args = { .teb = NtCurrentTeb(), .path = path, .reference = reference, .mask = mask, .coverMode = coverMode };
    NTSTATUS status;
    TRACE( "path %d, reference %d, mask %d, coverMode %d\n", path, reference, mask, coverMode );
    if ((status = UNIX_CALL( glStencilThenCoverStrokePathNV, &args ))) WARN( "glStencilThenCoverStrokePathNV returned %#lx\n", status );
}

static void WINAPI glStopInstrumentsSGIX( GLint marker )
{
    struct glStopInstrumentsSGIX_params args = { .teb = NtCurrentTeb(), .marker = marker };
    NTSTATUS status;
    TRACE( "marker %d\n", marker );
    if ((status = UNIX_CALL( glStopInstrumentsSGIX, &args ))) WARN( "glStopInstrumentsSGIX returned %#lx\n", status );
}

static void WINAPI glStringMarkerGREMEDY( GLsizei len, const void *string )
{
    struct glStringMarkerGREMEDY_params args = { .teb = NtCurrentTeb(), .len = len, .string = string };
    NTSTATUS status;
    TRACE( "len %d, string %p\n", len, string );
    if ((status = UNIX_CALL( glStringMarkerGREMEDY, &args ))) WARN( "glStringMarkerGREMEDY returned %#lx\n", status );
}

static void WINAPI glSubpixelPrecisionBiasNV( GLuint xbits, GLuint ybits )
{
    struct glSubpixelPrecisionBiasNV_params args = { .teb = NtCurrentTeb(), .xbits = xbits, .ybits = ybits };
    NTSTATUS status;
    TRACE( "xbits %d, ybits %d\n", xbits, ybits );
    if ((status = UNIX_CALL( glSubpixelPrecisionBiasNV, &args ))) WARN( "glSubpixelPrecisionBiasNV returned %#lx\n", status );
}

static void WINAPI glSwizzleEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW )
{
    struct glSwizzleEXT_params args = { .teb = NtCurrentTeb(), .res = res, .in = in, .outX = outX, .outY = outY, .outZ = outZ, .outW = outW };
    NTSTATUS status;
    TRACE( "res %d, in %d, outX %d, outY %d, outZ %d, outW %d\n", res, in, outX, outY, outZ, outW );
    if ((status = UNIX_CALL( glSwizzleEXT, &args ))) WARN( "glSwizzleEXT returned %#lx\n", status );
}

static void WINAPI glSyncTextureINTEL( GLuint texture )
{
    struct glSyncTextureINTEL_params args = { .teb = NtCurrentTeb(), .texture = texture };
    NTSTATUS status;
    TRACE( "texture %d\n", texture );
    if ((status = UNIX_CALL( glSyncTextureINTEL, &args ))) WARN( "glSyncTextureINTEL returned %#lx\n", status );
}

static void WINAPI glTagSampleBufferSGIX(void)
{
    struct glTagSampleBufferSGIX_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glTagSampleBufferSGIX, &args ))) WARN( "glTagSampleBufferSGIX returned %#lx\n", status );
}

static void WINAPI glTangent3bEXT( GLbyte tx, GLbyte ty, GLbyte tz )
{
    struct glTangent3bEXT_params args = { .teb = NtCurrentTeb(), .tx = tx, .ty = ty, .tz = tz };
    NTSTATUS status;
    TRACE( "tx %d, ty %d, tz %d\n", tx, ty, tz );
    if ((status = UNIX_CALL( glTangent3bEXT, &args ))) WARN( "glTangent3bEXT returned %#lx\n", status );
}

static void WINAPI glTangent3bvEXT( const GLbyte *v )
{
    struct glTangent3bvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTangent3bvEXT, &args ))) WARN( "glTangent3bvEXT returned %#lx\n", status );
}

static void WINAPI glTangent3dEXT( GLdouble tx, GLdouble ty, GLdouble tz )
{
    struct glTangent3dEXT_params args = { .teb = NtCurrentTeb(), .tx = tx, .ty = ty, .tz = tz };
    NTSTATUS status;
    TRACE( "tx %f, ty %f, tz %f\n", tx, ty, tz );
    if ((status = UNIX_CALL( glTangent3dEXT, &args ))) WARN( "glTangent3dEXT returned %#lx\n", status );
}

static void WINAPI glTangent3dvEXT( const GLdouble *v )
{
    struct glTangent3dvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTangent3dvEXT, &args ))) WARN( "glTangent3dvEXT returned %#lx\n", status );
}

static void WINAPI glTangent3fEXT( GLfloat tx, GLfloat ty, GLfloat tz )
{
    struct glTangent3fEXT_params args = { .teb = NtCurrentTeb(), .tx = tx, .ty = ty, .tz = tz };
    NTSTATUS status;
    TRACE( "tx %f, ty %f, tz %f\n", tx, ty, tz );
    if ((status = UNIX_CALL( glTangent3fEXT, &args ))) WARN( "glTangent3fEXT returned %#lx\n", status );
}

static void WINAPI glTangent3fvEXT( const GLfloat *v )
{
    struct glTangent3fvEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTangent3fvEXT, &args ))) WARN( "glTangent3fvEXT returned %#lx\n", status );
}

static void WINAPI glTangent3iEXT( GLint tx, GLint ty, GLint tz )
{
    struct glTangent3iEXT_params args = { .teb = NtCurrentTeb(), .tx = tx, .ty = ty, .tz = tz };
    NTSTATUS status;
    TRACE( "tx %d, ty %d, tz %d\n", tx, ty, tz );
    if ((status = UNIX_CALL( glTangent3iEXT, &args ))) WARN( "glTangent3iEXT returned %#lx\n", status );
}

static void WINAPI glTangent3ivEXT( const GLint *v )
{
    struct glTangent3ivEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTangent3ivEXT, &args ))) WARN( "glTangent3ivEXT returned %#lx\n", status );
}

static void WINAPI glTangent3sEXT( GLshort tx, GLshort ty, GLshort tz )
{
    struct glTangent3sEXT_params args = { .teb = NtCurrentTeb(), .tx = tx, .ty = ty, .tz = tz };
    NTSTATUS status;
    TRACE( "tx %d, ty %d, tz %d\n", tx, ty, tz );
    if ((status = UNIX_CALL( glTangent3sEXT, &args ))) WARN( "glTangent3sEXT returned %#lx\n", status );
}

static void WINAPI glTangent3svEXT( const GLshort *v )
{
    struct glTangent3svEXT_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTangent3svEXT, &args ))) WARN( "glTangent3svEXT returned %#lx\n", status );
}

static void WINAPI glTangentPointerEXT( GLenum type, GLsizei stride, const void *pointer )
{
    struct glTangentPointerEXT_params args = { .teb = NtCurrentTeb(), .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
    if ((status = UNIX_CALL( glTangentPointerEXT, &args ))) WARN( "glTangentPointerEXT returned %#lx\n", status );
}

static void WINAPI glTbufferMask3DFX( GLuint mask )
{
    struct glTbufferMask3DFX_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glTbufferMask3DFX, &args ))) WARN( "glTbufferMask3DFX returned %#lx\n", status );
}

static void WINAPI glTessellationFactorAMD( GLfloat factor )
{
    struct glTessellationFactorAMD_params args = { .teb = NtCurrentTeb(), .factor = factor };
    NTSTATUS status;
    TRACE( "factor %f\n", factor );
    if ((status = UNIX_CALL( glTessellationFactorAMD, &args ))) WARN( "glTessellationFactorAMD returned %#lx\n", status );
}

static void WINAPI glTessellationModeAMD( GLenum mode )
{
    struct glTessellationModeAMD_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glTessellationModeAMD, &args ))) WARN( "glTessellationModeAMD returned %#lx\n", status );
}

static GLboolean WINAPI glTestFenceAPPLE( GLuint fence )
{
    struct glTestFenceAPPLE_params args = { .teb = NtCurrentTeb(), .fence = fence };
    NTSTATUS status;
    TRACE( "fence %d\n", fence );
    if ((status = UNIX_CALL( glTestFenceAPPLE, &args ))) WARN( "glTestFenceAPPLE returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glTestFenceNV( GLuint fence )
{
    struct glTestFenceNV_params args = { .teb = NtCurrentTeb(), .fence = fence };
    NTSTATUS status;
    TRACE( "fence %d\n", fence );
    if ((status = UNIX_CALL( glTestFenceNV, &args ))) WARN( "glTestFenceNV returned %#lx\n", status );
    return args.ret;
}

static GLboolean WINAPI glTestObjectAPPLE( GLenum object, GLuint name )
{
    struct glTestObjectAPPLE_params args = { .teb = NtCurrentTeb(), .object = object, .name = name };
    NTSTATUS status;
    TRACE( "object %d, name %d\n", object, name );
    if ((status = UNIX_CALL( glTestObjectAPPLE, &args ))) WARN( "glTestObjectAPPLE returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glTexAttachMemoryNV( GLenum target, GLuint memory, GLuint64 offset )
{
    struct glTexAttachMemoryNV_params args = { .teb = NtCurrentTeb(), .target = target, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, memory %d, offset %s\n", target, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTexAttachMemoryNV, &args ))) WARN( "glTexAttachMemoryNV returned %#lx\n", status );
}

static void WINAPI glTexBuffer( GLenum target, GLenum internalformat, GLuint buffer )
{
    struct glTexBuffer_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .buffer = buffer };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, buffer %d\n", target, internalformat, buffer );
    if ((status = UNIX_CALL( glTexBuffer, &args ))) WARN( "glTexBuffer returned %#lx\n", status );
}

static void WINAPI glTexBufferARB( GLenum target, GLenum internalformat, GLuint buffer )
{
    struct glTexBufferARB_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .buffer = buffer };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, buffer %d\n", target, internalformat, buffer );
    if ((status = UNIX_CALL( glTexBufferARB, &args ))) WARN( "glTexBufferARB returned %#lx\n", status );
}

static void WINAPI glTexBufferEXT( GLenum target, GLenum internalformat, GLuint buffer )
{
    struct glTexBufferEXT_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .buffer = buffer };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, buffer %d\n", target, internalformat, buffer );
    if ((status = UNIX_CALL( glTexBufferEXT, &args ))) WARN( "glTexBufferEXT returned %#lx\n", status );
}

static void WINAPI glTexBufferRange( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
    struct glTexBufferRange_params args = { .teb = NtCurrentTeb(), .target = target, .internalformat = internalformat, .buffer = buffer, .offset = offset, .size = size };
    NTSTATUS status;
    TRACE( "target %d, internalformat %d, buffer %d, offset %Id, size %Id\n", target, internalformat, buffer, offset, size );
    if ((status = UNIX_CALL( glTexBufferRange, &args ))) WARN( "glTexBufferRange returned %#lx\n", status );
}

static void WINAPI glTexBumpParameterfvATI( GLenum pname, const GLfloat *param )
{
    struct glTexBumpParameterfvATI_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %p\n", pname, param );
    if ((status = UNIX_CALL( glTexBumpParameterfvATI, &args ))) WARN( "glTexBumpParameterfvATI returned %#lx\n", status );
}

static void WINAPI glTexBumpParameterivATI( GLenum pname, const GLint *param )
{
    struct glTexBumpParameterivATI_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %p\n", pname, param );
    if ((status = UNIX_CALL( glTexBumpParameterivATI, &args ))) WARN( "glTexBumpParameterivATI returned %#lx\n", status );
}

static void WINAPI glTexCoord1bOES( GLbyte s )
{
    struct glTexCoord1bOES_params args = { .teb = NtCurrentTeb(), .s = s };
    NTSTATUS status;
    TRACE( "s %d\n", s );
    if ((status = UNIX_CALL( glTexCoord1bOES, &args ))) WARN( "glTexCoord1bOES returned %#lx\n", status );
}

static void WINAPI glTexCoord1bvOES( const GLbyte *coords )
{
    struct glTexCoord1bvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glTexCoord1bvOES, &args ))) WARN( "glTexCoord1bvOES returned %#lx\n", status );
}

static void WINAPI glTexCoord1hNV( GLhalfNV s )
{
    struct glTexCoord1hNV_params args = { .teb = NtCurrentTeb(), .s = s };
    NTSTATUS status;
    TRACE( "s %d\n", s );
    if ((status = UNIX_CALL( glTexCoord1hNV, &args ))) WARN( "glTexCoord1hNV returned %#lx\n", status );
}

static void WINAPI glTexCoord1hvNV( const GLhalfNV *v )
{
    struct glTexCoord1hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord1hvNV, &args ))) WARN( "glTexCoord1hvNV returned %#lx\n", status );
}

static void WINAPI glTexCoord1xOES( GLfixed s )
{
    struct glTexCoord1xOES_params args = { .teb = NtCurrentTeb(), .s = s };
    NTSTATUS status;
    TRACE( "s %d\n", s );
    if ((status = UNIX_CALL( glTexCoord1xOES, &args ))) WARN( "glTexCoord1xOES returned %#lx\n", status );
}

static void WINAPI glTexCoord1xvOES( const GLfixed *coords )
{
    struct glTexCoord1xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glTexCoord1xvOES, &args ))) WARN( "glTexCoord1xvOES returned %#lx\n", status );
}

static void WINAPI glTexCoord2bOES( GLbyte s, GLbyte t )
{
    struct glTexCoord2bOES_params args = { .teb = NtCurrentTeb(), .s = s, .t = t };
    NTSTATUS status;
    TRACE( "s %d, t %d\n", s, t );
    if ((status = UNIX_CALL( glTexCoord2bOES, &args ))) WARN( "glTexCoord2bOES returned %#lx\n", status );
}

static void WINAPI glTexCoord2bvOES( const GLbyte *coords )
{
    struct glTexCoord2bvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glTexCoord2bvOES, &args ))) WARN( "glTexCoord2bvOES returned %#lx\n", status );
}

static void WINAPI glTexCoord2fColor3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z )
{
    struct glTexCoord2fColor3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .g = g, .b = b, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "s %f, t %f, r %f, g %f, b %f, x %f, y %f, z %f\n", s, t, r, g, b, x, y, z );
    if ((status = UNIX_CALL( glTexCoord2fColor3fVertex3fSUN, &args ))) WARN( "glTexCoord2fColor3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2fColor3fVertex3fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *v )
{
    struct glTexCoord2fColor3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .tc = tc, .c = c, .v = v };
    NTSTATUS status;
    TRACE( "tc %p, c %p, v %p\n", tc, c, v );
    if ((status = UNIX_CALL( glTexCoord2fColor3fVertex3fvSUN, &args ))) WARN( "glTexCoord2fColor3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI 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 )
{
    struct glTexCoord2fColor4fNormal3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .g = g, .b = b, .a = a, .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "s %f, t %f, r %f, g %f, b %f, a %f, nx %f, ny %f, nz %f, x %f, y %f, z %f\n", s, t, r, g, b, a, nx, ny, nz, x, y, z );
    if ((status = UNIX_CALL( glTexCoord2fColor4fNormal3fVertex3fSUN, &args ))) WARN( "glTexCoord2fColor4fNormal3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2fColor4fNormal3fVertex3fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v )
{
    struct glTexCoord2fColor4fNormal3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .tc = tc, .c = c, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "tc %p, c %p, n %p, v %p\n", tc, c, n, v );
    if ((status = UNIX_CALL( glTexCoord2fColor4fNormal3fVertex3fvSUN, &args ))) WARN( "glTexCoord2fColor4fNormal3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2fColor4ubVertex3fSUN( GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z )
{
    struct glTexCoord2fColor4ubVertex3fSUN_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .g = g, .b = b, .a = a, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "s %f, t %f, r %d, g %d, b %d, a %d, x %f, y %f, z %f\n", s, t, r, g, b, a, x, y, z );
    if ((status = UNIX_CALL( glTexCoord2fColor4ubVertex3fSUN, &args ))) WARN( "glTexCoord2fColor4ubVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2fColor4ubVertex3fvSUN( const GLfloat *tc, const GLubyte *c, const GLfloat *v )
{
    struct glTexCoord2fColor4ubVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .tc = tc, .c = c, .v = v };
    NTSTATUS status;
    TRACE( "tc %p, c %p, v %p\n", tc, c, v );
    if ((status = UNIX_CALL( glTexCoord2fColor4ubVertex3fvSUN, &args ))) WARN( "glTexCoord2fColor4ubVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
{
    struct glTexCoord2fNormal3fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "s %f, t %f, nx %f, ny %f, nz %f, x %f, y %f, z %f\n", s, t, nx, ny, nz, x, y, z );
    if ((status = UNIX_CALL( glTexCoord2fNormal3fVertex3fSUN, &args ))) WARN( "glTexCoord2fNormal3fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2fNormal3fVertex3fvSUN( const GLfloat *tc, const GLfloat *n, const GLfloat *v )
{
    struct glTexCoord2fNormal3fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .tc = tc, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "tc %p, n %p, v %p\n", tc, n, v );
    if ((status = UNIX_CALL( glTexCoord2fNormal3fVertex3fvSUN, &args ))) WARN( "glTexCoord2fNormal3fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2fVertex3fSUN( GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z )
{
    struct glTexCoord2fVertex3fSUN_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "s %f, t %f, x %f, y %f, z %f\n", s, t, x, y, z );
    if ((status = UNIX_CALL( glTexCoord2fVertex3fSUN, &args ))) WARN( "glTexCoord2fVertex3fSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2fVertex3fvSUN( const GLfloat *tc, const GLfloat *v )
{
    struct glTexCoord2fVertex3fvSUN_params args = { .teb = NtCurrentTeb(), .tc = tc, .v = v };
    NTSTATUS status;
    TRACE( "tc %p, v %p\n", tc, v );
    if ((status = UNIX_CALL( glTexCoord2fVertex3fvSUN, &args ))) WARN( "glTexCoord2fVertex3fvSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord2hNV( GLhalfNV s, GLhalfNV t )
{
    struct glTexCoord2hNV_params args = { .teb = NtCurrentTeb(), .s = s, .t = t };
    NTSTATUS status;
    TRACE( "s %d, t %d\n", s, t );
    if ((status = UNIX_CALL( glTexCoord2hNV, &args ))) WARN( "glTexCoord2hNV returned %#lx\n", status );
}

static void WINAPI glTexCoord2hvNV( const GLhalfNV *v )
{
    struct glTexCoord2hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord2hvNV, &args ))) WARN( "glTexCoord2hvNV returned %#lx\n", status );
}

static void WINAPI glTexCoord2xOES( GLfixed s, GLfixed t )
{
    struct glTexCoord2xOES_params args = { .teb = NtCurrentTeb(), .s = s, .t = t };
    NTSTATUS status;
    TRACE( "s %d, t %d\n", s, t );
    if ((status = UNIX_CALL( glTexCoord2xOES, &args ))) WARN( "glTexCoord2xOES returned %#lx\n", status );
}

static void WINAPI glTexCoord2xvOES( const GLfixed *coords )
{
    struct glTexCoord2xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glTexCoord2xvOES, &args ))) WARN( "glTexCoord2xvOES returned %#lx\n", status );
}

static void WINAPI glTexCoord3bOES( GLbyte s, GLbyte t, GLbyte r )
{
    struct glTexCoord3bOES_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d\n", s, t, r );
    if ((status = UNIX_CALL( glTexCoord3bOES, &args ))) WARN( "glTexCoord3bOES returned %#lx\n", status );
}

static void WINAPI glTexCoord3bvOES( const GLbyte *coords )
{
    struct glTexCoord3bvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glTexCoord3bvOES, &args ))) WARN( "glTexCoord3bvOES returned %#lx\n", status );
}

static void WINAPI glTexCoord3hNV( GLhalfNV s, GLhalfNV t, GLhalfNV r )
{
    struct glTexCoord3hNV_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d\n", s, t, r );
    if ((status = UNIX_CALL( glTexCoord3hNV, &args ))) WARN( "glTexCoord3hNV returned %#lx\n", status );
}

static void WINAPI glTexCoord3hvNV( const GLhalfNV *v )
{
    struct glTexCoord3hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord3hvNV, &args ))) WARN( "glTexCoord3hvNV returned %#lx\n", status );
}

static void WINAPI glTexCoord3xOES( GLfixed s, GLfixed t, GLfixed r )
{
    struct glTexCoord3xOES_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d\n", s, t, r );
    if ((status = UNIX_CALL( glTexCoord3xOES, &args ))) WARN( "glTexCoord3xOES returned %#lx\n", status );
}

static void WINAPI glTexCoord3xvOES( const GLfixed *coords )
{
    struct glTexCoord3xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glTexCoord3xvOES, &args ))) WARN( "glTexCoord3xvOES returned %#lx\n", status );
}

static void WINAPI glTexCoord4bOES( GLbyte s, GLbyte t, GLbyte r, GLbyte q )
{
    struct glTexCoord4bOES_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d, q %d\n", s, t, r, q );
    if ((status = UNIX_CALL( glTexCoord4bOES, &args ))) WARN( "glTexCoord4bOES returned %#lx\n", status );
}

static void WINAPI glTexCoord4bvOES( const GLbyte *coords )
{
    struct glTexCoord4bvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glTexCoord4bvOES, &args ))) WARN( "glTexCoord4bvOES returned %#lx\n", status );
}

static void WINAPI 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 )
{
    struct glTexCoord4fColor4fNormal3fVertex4fSUN_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .p = p, .q = q, .r = r, .g = g, .b = b, .a = a, .nx = nx, .ny = ny, .nz = nz, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "s %f, t %f, p %f, q %f, r %f, g %f, b %f, a %f, nx %f, ny %f, nz %f, x %f, y %f, z %f, w %f\n", s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w );
    if ((status = UNIX_CALL( glTexCoord4fColor4fNormal3fVertex4fSUN, &args ))) WARN( "glTexCoord4fColor4fNormal3fVertex4fSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord4fColor4fNormal3fVertex4fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v )
{
    struct glTexCoord4fColor4fNormal3fVertex4fvSUN_params args = { .teb = NtCurrentTeb(), .tc = tc, .c = c, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "tc %p, c %p, n %p, v %p\n", tc, c, n, v );
    if ((status = UNIX_CALL( glTexCoord4fColor4fNormal3fVertex4fvSUN, &args ))) WARN( "glTexCoord4fColor4fNormal3fVertex4fvSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord4fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glTexCoord4fVertex4fSUN_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .p = p, .q = q, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "s %f, t %f, p %f, q %f, x %f, y %f, z %f, w %f\n", s, t, p, q, x, y, z, w );
    if ((status = UNIX_CALL( glTexCoord4fVertex4fSUN, &args ))) WARN( "glTexCoord4fVertex4fSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord4fVertex4fvSUN( const GLfloat *tc, const GLfloat *v )
{
    struct glTexCoord4fVertex4fvSUN_params args = { .teb = NtCurrentTeb(), .tc = tc, .v = v };
    NTSTATUS status;
    TRACE( "tc %p, v %p\n", tc, v );
    if ((status = UNIX_CALL( glTexCoord4fVertex4fvSUN, &args ))) WARN( "glTexCoord4fVertex4fvSUN returned %#lx\n", status );
}

static void WINAPI glTexCoord4hNV( GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q )
{
    struct glTexCoord4hNV_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d, q %d\n", s, t, r, q );
    if ((status = UNIX_CALL( glTexCoord4hNV, &args ))) WARN( "glTexCoord4hNV returned %#lx\n", status );
}

static void WINAPI glTexCoord4hvNV( const GLhalfNV *v )
{
    struct glTexCoord4hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glTexCoord4hvNV, &args ))) WARN( "glTexCoord4hvNV returned %#lx\n", status );
}

static void WINAPI glTexCoord4xOES( GLfixed s, GLfixed t, GLfixed r, GLfixed q )
{
    struct glTexCoord4xOES_params args = { .teb = NtCurrentTeb(), .s = s, .t = t, .r = r, .q = q };
    NTSTATUS status;
    TRACE( "s %d, t %d, r %d, q %d\n", s, t, r, q );
    if ((status = UNIX_CALL( glTexCoord4xOES, &args ))) WARN( "glTexCoord4xOES returned %#lx\n", status );
}

static void WINAPI glTexCoord4xvOES( const GLfixed *coords )
{
    struct glTexCoord4xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glTexCoord4xvOES, &args ))) WARN( "glTexCoord4xvOES returned %#lx\n", status );
}

static void WINAPI glTexCoordFormatNV( GLint size, GLenum type, GLsizei stride )
{
    struct glTexCoordFormatNV_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d\n", size, type, stride );
    if ((status = UNIX_CALL( glTexCoordFormatNV, &args ))) WARN( "glTexCoordFormatNV returned %#lx\n", status );
}

static void WINAPI glTexCoordP1ui( GLenum type, GLuint coords )
{
    struct glTexCoordP1ui_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %d\n", type, coords );
    if ((status = UNIX_CALL( glTexCoordP1ui, &args ))) WARN( "glTexCoordP1ui returned %#lx\n", status );
}

static void WINAPI glTexCoordP1uiv( GLenum type, const GLuint *coords )
{
    struct glTexCoordP1uiv_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %p\n", type, coords );
    if ((status = UNIX_CALL( glTexCoordP1uiv, &args ))) WARN( "glTexCoordP1uiv returned %#lx\n", status );
}

static void WINAPI glTexCoordP2ui( GLenum type, GLuint coords )
{
    struct glTexCoordP2ui_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %d\n", type, coords );
    if ((status = UNIX_CALL( glTexCoordP2ui, &args ))) WARN( "glTexCoordP2ui returned %#lx\n", status );
}

static void WINAPI glTexCoordP2uiv( GLenum type, const GLuint *coords )
{
    struct glTexCoordP2uiv_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %p\n", type, coords );
    if ((status = UNIX_CALL( glTexCoordP2uiv, &args ))) WARN( "glTexCoordP2uiv returned %#lx\n", status );
}

static void WINAPI glTexCoordP3ui( GLenum type, GLuint coords )
{
    struct glTexCoordP3ui_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %d\n", type, coords );
    if ((status = UNIX_CALL( glTexCoordP3ui, &args ))) WARN( "glTexCoordP3ui returned %#lx\n", status );
}

static void WINAPI glTexCoordP3uiv( GLenum type, const GLuint *coords )
{
    struct glTexCoordP3uiv_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %p\n", type, coords );
    if ((status = UNIX_CALL( glTexCoordP3uiv, &args ))) WARN( "glTexCoordP3uiv returned %#lx\n", status );
}

static void WINAPI glTexCoordP4ui( GLenum type, GLuint coords )
{
    struct glTexCoordP4ui_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %d\n", type, coords );
    if ((status = UNIX_CALL( glTexCoordP4ui, &args ))) WARN( "glTexCoordP4ui returned %#lx\n", status );
}

static void WINAPI glTexCoordP4uiv( GLenum type, const GLuint *coords )
{
    struct glTexCoordP4uiv_params args = { .teb = NtCurrentTeb(), .type = type, .coords = coords };
    NTSTATUS status;
    TRACE( "type %d, coords %p\n", type, coords );
    if ((status = UNIX_CALL( glTexCoordP4uiv, &args ))) WARN( "glTexCoordP4uiv returned %#lx\n", status );
}

static void WINAPI glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer )
{
    struct glTexCoordPointerEXT_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .count = count, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, count %d, pointer %p\n", size, type, stride, count, pointer );
    if ((status = UNIX_CALL( glTexCoordPointerEXT, &args ))) WARN( "glTexCoordPointerEXT returned %#lx\n", status );
}

static void WINAPI glTexCoordPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride )
{
    struct glTexCoordPointerListIBM_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer, .ptrstride = ptrstride };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p, ptrstride %d\n", size, type, stride, pointer, ptrstride );
    if ((status = UNIX_CALL( glTexCoordPointerListIBM, &args ))) WARN( "glTexCoordPointerListIBM returned %#lx\n", status );
}

static void WINAPI glTexCoordPointervINTEL( GLint size, GLenum type, const void **pointer )
{
    struct glTexCoordPointervINTEL_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, pointer %p\n", size, type, pointer );
    if ((status = UNIX_CALL( glTexCoordPointervINTEL, &args ))) WARN( "glTexCoordPointervINTEL returned %#lx\n", status );
}

static void WINAPI glTexEnvxOES( GLenum target, GLenum pname, GLfixed param )
{
    struct glTexEnvxOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glTexEnvxOES, &args ))) WARN( "glTexEnvxOES returned %#lx\n", status );
}

static void WINAPI glTexEnvxvOES( GLenum target, GLenum pname, const GLfixed *params )
{
    struct glTexEnvxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexEnvxvOES, &args ))) WARN( "glTexEnvxvOES returned %#lx\n", status );
}

static void WINAPI glTexFilterFuncSGIS( GLenum target, GLenum filter, GLsizei n, const GLfloat *weights )
{
    struct glTexFilterFuncSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .filter = filter, .n = n, .weights = weights };
    NTSTATUS status;
    TRACE( "target %d, filter %d, n %d, weights %p\n", target, filter, n, weights );
    if ((status = UNIX_CALL( glTexFilterFuncSGIS, &args ))) WARN( "glTexFilterFuncSGIS returned %#lx\n", status );
}

static void WINAPI glTexGenxOES( GLenum coord, GLenum pname, GLfixed param )
{
    struct glTexGenxOES_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, param %d\n", coord, pname, param );
    if ((status = UNIX_CALL( glTexGenxOES, &args ))) WARN( "glTexGenxOES returned %#lx\n", status );
}

static void WINAPI glTexGenxvOES( GLenum coord, GLenum pname, const GLfixed *params )
{
    struct glTexGenxvOES_params args = { .teb = NtCurrentTeb(), .coord = coord, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
    if ((status = UNIX_CALL( glTexGenxvOES, &args ))) WARN( "glTexGenxvOES returned %#lx\n", status );
}

static void WINAPI glTexImage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
{
    struct glTexImage2DMultisample_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .internalformat = internalformat, .width = width, .height = height, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "target %d, samples %d, internalformat %d, width %d, height %d, fixedsamplelocations %d\n", target, samples, internalformat, width, height, fixedsamplelocations );
    if ((status = UNIX_CALL( glTexImage2DMultisample, &args ))) WARN( "glTexImage2DMultisample returned %#lx\n", status );
}

static void WINAPI glTexImage2DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations )
{
    struct glTexImage2DMultisampleCoverageNV_params args = { .teb = NtCurrentTeb(), .target = target, .coverageSamples = coverageSamples, .colorSamples = colorSamples, .internalFormat = internalFormat, .width = width, .height = height, .fixedSampleLocations = fixedSampleLocations };
    NTSTATUS status;
    TRACE( "target %d, coverageSamples %d, colorSamples %d, internalFormat %d, width %d, height %d, fixedSampleLocations %d\n", target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations );
    if ((status = UNIX_CALL( glTexImage2DMultisampleCoverageNV, &args ))) WARN( "glTexImage2DMultisampleCoverageNV returned %#lx\n", status );
}

static void WINAPI glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glTexImage3D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, depth %d, border %d, format %d, type %d, pixels %p\n", target, level, internalformat, width, height, depth, border, format, type, pixels );
    if ((status = UNIX_CALL( glTexImage3D, &args ))) WARN( "glTexImage3D returned %#lx\n", status );
}

static void WINAPI glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glTexImage3DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, depth %d, border %d, format %d, type %d, pixels %p\n", target, level, internalformat, width, height, depth, border, format, type, pixels );
    if ((status = UNIX_CALL( glTexImage3DEXT, &args ))) WARN( "glTexImage3DEXT returned %#lx\n", status );
}

static void WINAPI glTexImage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
{
    struct glTexImage3DMultisample_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "target %d, samples %d, internalformat %d, width %d, height %d, depth %d, fixedsamplelocations %d\n", target, samples, internalformat, width, height, depth, fixedsamplelocations );
    if ((status = UNIX_CALL( glTexImage3DMultisample, &args ))) WARN( "glTexImage3DMultisample returned %#lx\n", status );
}

static void WINAPI glTexImage3DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations )
{
    struct glTexImage3DMultisampleCoverageNV_params args = { .teb = NtCurrentTeb(), .target = target, .coverageSamples = coverageSamples, .colorSamples = colorSamples, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .fixedSampleLocations = fixedSampleLocations };
    NTSTATUS status;
    TRACE( "target %d, coverageSamples %d, colorSamples %d, internalFormat %d, width %d, height %d, depth %d, fixedSampleLocations %d\n", target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations );
    if ((status = UNIX_CALL( glTexImage3DMultisampleCoverageNV, &args ))) WARN( "glTexImage3DMultisampleCoverageNV returned %#lx\n", status );
}

static void WINAPI glTexImage4DSGIS( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glTexImage4DSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .size4d = size4d, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, depth %d, size4d %d, border %d, format %d, type %d, pixels %p\n", target, level, internalformat, width, height, depth, size4d, border, format, type, pixels );
    if ((status = UNIX_CALL( glTexImage4DSGIS, &args ))) WARN( "glTexImage4DSGIS returned %#lx\n", status );
}

static void WINAPI glTexPageCommitmentARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit )
{
    struct glTexPageCommitmentARB_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .commit = commit };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, commit %d\n", target, level, xoffset, yoffset, zoffset, width, height, depth, commit );
    if ((status = UNIX_CALL( glTexPageCommitmentARB, &args ))) WARN( "glTexPageCommitmentARB returned %#lx\n", status );
}

static void WINAPI glTexParameterIiv( GLenum target, GLenum pname, const GLint *params )
{
    struct glTexParameterIiv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexParameterIiv, &args ))) WARN( "glTexParameterIiv returned %#lx\n", status );
}

static void WINAPI glTexParameterIivEXT( GLenum target, GLenum pname, const GLint *params )
{
    struct glTexParameterIivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexParameterIivEXT, &args ))) WARN( "glTexParameterIivEXT returned %#lx\n", status );
}

static void WINAPI glTexParameterIuiv( GLenum target, GLenum pname, const GLuint *params )
{
    struct glTexParameterIuiv_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexParameterIuiv, &args ))) WARN( "glTexParameterIuiv returned %#lx\n", status );
}

static void WINAPI glTexParameterIuivEXT( GLenum target, GLenum pname, const GLuint *params )
{
    struct glTexParameterIuivEXT_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexParameterIuivEXT, &args ))) WARN( "glTexParameterIuivEXT returned %#lx\n", status );
}

static void WINAPI glTexParameterxOES( GLenum target, GLenum pname, GLfixed param )
{
    struct glTexParameterxOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
    if ((status = UNIX_CALL( glTexParameterxOES, &args ))) WARN( "glTexParameterxOES returned %#lx\n", status );
}

static void WINAPI glTexParameterxvOES( GLenum target, GLenum pname, const GLfixed *params )
{
    struct glTexParameterxvOES_params args = { .teb = NtCurrentTeb(), .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
    if ((status = UNIX_CALL( glTexParameterxvOES, &args ))) WARN( "glTexParameterxvOES returned %#lx\n", status );
}

static void WINAPI glTexRenderbufferNV( GLenum target, GLuint renderbuffer )
{
    struct glTexRenderbufferNV_params args = { .teb = NtCurrentTeb(), .target = target, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "target %d, renderbuffer %d\n", target, renderbuffer );
    if ((status = UNIX_CALL( glTexRenderbufferNV, &args ))) WARN( "glTexRenderbufferNV returned %#lx\n", status );
}

static void WINAPI glTexStorage1D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width )
{
    struct glTexStorage1D_params args = { .teb = NtCurrentTeb(), .target = target, .levels = levels, .internalformat = internalformat, .width = width };
    NTSTATUS status;
    TRACE( "target %d, levels %d, internalformat %d, width %d\n", target, levels, internalformat, width );
    if ((status = UNIX_CALL( glTexStorage1D, &args ))) WARN( "glTexStorage1D returned %#lx\n", status );
}

static void WINAPI glTexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glTexStorage2D_params args = { .teb = NtCurrentTeb(), .target = target, .levels = levels, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "target %d, levels %d, internalformat %d, width %d, height %d\n", target, levels, internalformat, width, height );
    if ((status = UNIX_CALL( glTexStorage2D, &args ))) WARN( "glTexStorage2D returned %#lx\n", status );
}

static void WINAPI glTexStorage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
{
    struct glTexStorage2DMultisample_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .internalformat = internalformat, .width = width, .height = height, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "target %d, samples %d, internalformat %d, width %d, height %d, fixedsamplelocations %d\n", target, samples, internalformat, width, height, fixedsamplelocations );
    if ((status = UNIX_CALL( glTexStorage2DMultisample, &args ))) WARN( "glTexStorage2DMultisample returned %#lx\n", status );
}

static void WINAPI glTexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth )
{
    struct glTexStorage3D_params args = { .teb = NtCurrentTeb(), .target = target, .levels = levels, .internalformat = internalformat, .width = width, .height = height, .depth = depth };
    NTSTATUS status;
    TRACE( "target %d, levels %d, internalformat %d, width %d, height %d, depth %d\n", target, levels, internalformat, width, height, depth );
    if ((status = UNIX_CALL( glTexStorage3D, &args ))) WARN( "glTexStorage3D returned %#lx\n", status );
}

static void WINAPI glTexStorage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
{
    struct glTexStorage3DMultisample_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "target %d, samples %d, internalformat %d, width %d, height %d, depth %d, fixedsamplelocations %d\n", target, samples, internalformat, width, height, depth, fixedsamplelocations );
    if ((status = UNIX_CALL( glTexStorage3DMultisample, &args ))) WARN( "glTexStorage3DMultisample returned %#lx\n", status );
}

static void WINAPI glTexStorageMem1DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset )
{
    struct glTexStorageMem1DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .levels = levels, .internalFormat = internalFormat, .width = width, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, levels %d, internalFormat %d, width %d, memory %d, offset %s\n", target, levels, internalFormat, width, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTexStorageMem1DEXT, &args ))) WARN( "glTexStorageMem1DEXT returned %#lx\n", status );
}

static void WINAPI glTexStorageMem2DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset )
{
    struct glTexStorageMem2DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .levels = levels, .internalFormat = internalFormat, .width = width, .height = height, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, levels %d, internalFormat %d, width %d, height %d, memory %d, offset %s\n", target, levels, internalFormat, width, height, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTexStorageMem2DEXT, &args ))) WARN( "glTexStorageMem2DEXT returned %#lx\n", status );
}

static void WINAPI glTexStorageMem2DMultisampleEXT( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset )
{
    struct glTexStorageMem2DMultisampleEXT_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .internalFormat = internalFormat, .width = width, .height = height, .fixedSampleLocations = fixedSampleLocations, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, samples %d, internalFormat %d, width %d, height %d, fixedSampleLocations %d, memory %d, offset %s\n", target, samples, internalFormat, width, height, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTexStorageMem2DMultisampleEXT, &args ))) WARN( "glTexStorageMem2DMultisampleEXT returned %#lx\n", status );
}

static void WINAPI glTexStorageMem3DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset )
{
    struct glTexStorageMem3DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .levels = levels, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, levels %d, internalFormat %d, width %d, height %d, depth %d, memory %d, offset %s\n", target, levels, internalFormat, width, height, depth, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTexStorageMem3DEXT, &args ))) WARN( "glTexStorageMem3DEXT returned %#lx\n", status );
}

static void WINAPI glTexStorageMem3DMultisampleEXT( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset )
{
    struct glTexStorageMem3DMultisampleEXT_params args = { .teb = NtCurrentTeb(), .target = target, .samples = samples, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .fixedSampleLocations = fixedSampleLocations, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "target %d, samples %d, internalFormat %d, width %d, height %d, depth %d, fixedSampleLocations %d, memory %d, offset %s\n", target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTexStorageMem3DMultisampleEXT, &args ))) WARN( "glTexStorageMem3DMultisampleEXT returned %#lx\n", status );
}

static void WINAPI glTexStorageSparseAMD( GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags )
{
    struct glTexStorageSparseAMD_params args = { .teb = NtCurrentTeb(), .target = target, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .layers = layers, .flags = flags };
    NTSTATUS status;
    TRACE( "target %d, internalFormat %d, width %d, height %d, depth %d, layers %d, flags %d\n", target, internalFormat, width, height, depth, layers, flags );
    if ((status = UNIX_CALL( glTexStorageSparseAMD, &args ))) WARN( "glTexStorageSparseAMD returned %#lx\n", status );
}

static void WINAPI glTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
{
    struct glTexSubImage1DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, width %d, format %d, type %d, pixels %p\n", target, level, xoffset, width, format, type, pixels );
    if ((status = UNIX_CALL( glTexSubImage1DEXT, &args ))) WARN( "glTexSubImage1DEXT returned %#lx\n", status );
}

static void WINAPI glTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
{
    struct glTexSubImage2DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, type %d, pixels %p\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
    if ((status = UNIX_CALL( glTexSubImage2DEXT, &args ))) WARN( "glTexSubImage2DEXT returned %#lx\n", status );
}

static void WINAPI glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
{
    struct glTexSubImage3D_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, type %d, pixels %p\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
    if ((status = UNIX_CALL( glTexSubImage3D, &args ))) WARN( "glTexSubImage3D returned %#lx\n", status );
}

static void WINAPI glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
{
    struct glTexSubImage3DEXT_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, type %d, pixels %p\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
    if ((status = UNIX_CALL( glTexSubImage3DEXT, &args ))) WARN( "glTexSubImage3DEXT returned %#lx\n", status );
}

static void WINAPI glTexSubImage4DSGIS( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void *pixels )
{
    struct glTexSubImage4DSGIS_params args = { .teb = NtCurrentTeb(), .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .woffset = woffset, .width = width, .height = height, .depth = depth, .size4d = size4d, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "target %d, level %d, xoffset %d, yoffset %d, zoffset %d, woffset %d, width %d, height %d, depth %d, size4d %d, format %d, type %d, pixels %p\n", target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels );
    if ((status = UNIX_CALL( glTexSubImage4DSGIS, &args ))) WARN( "glTexSubImage4DSGIS returned %#lx\n", status );
}

static void WINAPI glTextureAttachMemoryNV( GLuint texture, GLuint memory, GLuint64 offset )
{
    struct glTextureAttachMemoryNV_params args = { .teb = NtCurrentTeb(), .texture = texture, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "texture %d, memory %d, offset %s\n", texture, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTextureAttachMemoryNV, &args ))) WARN( "glTextureAttachMemoryNV returned %#lx\n", status );
}

static void WINAPI glTextureBarrier(void)
{
    struct glTextureBarrier_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glTextureBarrier, &args ))) WARN( "glTextureBarrier returned %#lx\n", status );
}

static void WINAPI glTextureBarrierNV(void)
{
    struct glTextureBarrierNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glTextureBarrierNV, &args ))) WARN( "glTextureBarrierNV returned %#lx\n", status );
}

static void WINAPI glTextureBuffer( GLuint texture, GLenum internalformat, GLuint buffer )
{
    struct glTextureBuffer_params args = { .teb = NtCurrentTeb(), .texture = texture, .internalformat = internalformat, .buffer = buffer };
    NTSTATUS status;
    TRACE( "texture %d, internalformat %d, buffer %d\n", texture, internalformat, buffer );
    if ((status = UNIX_CALL( glTextureBuffer, &args ))) WARN( "glTextureBuffer returned %#lx\n", status );
}

static void WINAPI glTextureBufferEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer )
{
    struct glTextureBufferEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .internalformat = internalformat, .buffer = buffer };
    NTSTATUS status;
    TRACE( "texture %d, target %d, internalformat %d, buffer %d\n", texture, target, internalformat, buffer );
    if ((status = UNIX_CALL( glTextureBufferEXT, &args ))) WARN( "glTextureBufferEXT returned %#lx\n", status );
}

static void WINAPI glTextureBufferRange( GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
    struct glTextureBufferRange_params args = { .teb = NtCurrentTeb(), .texture = texture, .internalformat = internalformat, .buffer = buffer, .offset = offset, .size = size };
    NTSTATUS status;
    TRACE( "texture %d, internalformat %d, buffer %d, offset %Id, size %Id\n", texture, internalformat, buffer, offset, size );
    if ((status = UNIX_CALL( glTextureBufferRange, &args ))) WARN( "glTextureBufferRange returned %#lx\n", status );
}

static void WINAPI glTextureBufferRangeEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
    struct glTextureBufferRangeEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .internalformat = internalformat, .buffer = buffer, .offset = offset, .size = size };
    NTSTATUS status;
    TRACE( "texture %d, target %d, internalformat %d, buffer %d, offset %Id, size %Id\n", texture, target, internalformat, buffer, offset, size );
    if ((status = UNIX_CALL( glTextureBufferRangeEXT, &args ))) WARN( "glTextureBufferRangeEXT returned %#lx\n", status );
}

static void WINAPI glTextureColorMaskSGIS( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
{
    struct glTextureColorMaskSGIS_params args = { .teb = NtCurrentTeb(), .red = red, .green = green, .blue = blue, .alpha = alpha };
    NTSTATUS status;
    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
    if ((status = UNIX_CALL( glTextureColorMaskSGIS, &args ))) WARN( "glTextureColorMaskSGIS returned %#lx\n", status );
}

static void WINAPI glTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureImage1DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .internalformat = internalformat, .width = width, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, internalformat %d, width %d, border %d, format %d, type %d, pixels %p\n", texture, target, level, internalformat, width, border, format, type, pixels );
    if ((status = UNIX_CALL( glTextureImage1DEXT, &args ))) WARN( "glTextureImage1DEXT returned %#lx\n", status );
}

static void WINAPI glTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureImage2DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, internalformat %d, width %d, height %d, border %d, format %d, type %d, pixels %p\n", texture, target, level, internalformat, width, height, border, format, type, pixels );
    if ((status = UNIX_CALL( glTextureImage2DEXT, &args ))) WARN( "glTextureImage2DEXT returned %#lx\n", status );
}

static void WINAPI glTextureImage2DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations )
{
    struct glTextureImage2DMultisampleCoverageNV_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .coverageSamples = coverageSamples, .colorSamples = colorSamples, .internalFormat = internalFormat, .width = width, .height = height, .fixedSampleLocations = fixedSampleLocations };
    NTSTATUS status;
    TRACE( "texture %d, target %d, coverageSamples %d, colorSamples %d, internalFormat %d, width %d, height %d, fixedSampleLocations %d\n", texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations );
    if ((status = UNIX_CALL( glTextureImage2DMultisampleCoverageNV, &args ))) WARN( "glTextureImage2DMultisampleCoverageNV returned %#lx\n", status );
}

static void WINAPI glTextureImage2DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations )
{
    struct glTextureImage2DMultisampleNV_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .samples = samples, .internalFormat = internalFormat, .width = width, .height = height, .fixedSampleLocations = fixedSampleLocations };
    NTSTATUS status;
    TRACE( "texture %d, target %d, samples %d, internalFormat %d, width %d, height %d, fixedSampleLocations %d\n", texture, target, samples, internalFormat, width, height, fixedSampleLocations );
    if ((status = UNIX_CALL( glTextureImage2DMultisampleNV, &args ))) WARN( "glTextureImage2DMultisampleNV returned %#lx\n", status );
}

static void WINAPI glTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureImage3DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .border = border, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, internalformat %d, width %d, height %d, depth %d, border %d, format %d, type %d, pixels %p\n", texture, target, level, internalformat, width, height, depth, border, format, type, pixels );
    if ((status = UNIX_CALL( glTextureImage3DEXT, &args ))) WARN( "glTextureImage3DEXT returned %#lx\n", status );
}

static void WINAPI glTextureImage3DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations )
{
    struct glTextureImage3DMultisampleCoverageNV_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .coverageSamples = coverageSamples, .colorSamples = colorSamples, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .fixedSampleLocations = fixedSampleLocations };
    NTSTATUS status;
    TRACE( "texture %d, target %d, coverageSamples %d, colorSamples %d, internalFormat %d, width %d, height %d, depth %d, fixedSampleLocations %d\n", texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations );
    if ((status = UNIX_CALL( glTextureImage3DMultisampleCoverageNV, &args ))) WARN( "glTextureImage3DMultisampleCoverageNV returned %#lx\n", status );
}

static void WINAPI glTextureImage3DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations )
{
    struct glTextureImage3DMultisampleNV_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .samples = samples, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .fixedSampleLocations = fixedSampleLocations };
    NTSTATUS status;
    TRACE( "texture %d, target %d, samples %d, internalFormat %d, width %d, height %d, depth %d, fixedSampleLocations %d\n", texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations );
    if ((status = UNIX_CALL( glTextureImage3DMultisampleNV, &args ))) WARN( "glTextureImage3DMultisampleNV returned %#lx\n", status );
}

static void WINAPI glTextureLightEXT( GLenum pname )
{
    struct glTextureLightEXT_params args = { .teb = NtCurrentTeb(), .pname = pname };
    NTSTATUS status;
    TRACE( "pname %d\n", pname );
    if ((status = UNIX_CALL( glTextureLightEXT, &args ))) WARN( "glTextureLightEXT returned %#lx\n", status );
}

static void WINAPI glTextureMaterialEXT( GLenum face, GLenum mode )
{
    struct glTextureMaterialEXT_params args = { .teb = NtCurrentTeb(), .face = face, .mode = mode };
    NTSTATUS status;
    TRACE( "face %d, mode %d\n", face, mode );
    if ((status = UNIX_CALL( glTextureMaterialEXT, &args ))) WARN( "glTextureMaterialEXT returned %#lx\n", status );
}

static void WINAPI glTextureNormalEXT( GLenum mode )
{
    struct glTextureNormalEXT_params args = { .teb = NtCurrentTeb(), .mode = mode };
    NTSTATUS status;
    TRACE( "mode %d\n", mode );
    if ((status = UNIX_CALL( glTextureNormalEXT, &args ))) WARN( "glTextureNormalEXT returned %#lx\n", status );
}

static void WINAPI glTexturePageCommitmentEXT( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit )
{
    struct glTexturePageCommitmentEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .commit = commit };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, commit %d\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, commit );
    if ((status = UNIX_CALL( glTexturePageCommitmentEXT, &args ))) WARN( "glTexturePageCommitmentEXT returned %#lx\n", status );
}

static void WINAPI glTextureParameterIiv( GLuint texture, GLenum pname, const GLint *params )
{
    struct glTextureParameterIiv_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, params %p\n", texture, pname, params );
    if ((status = UNIX_CALL( glTextureParameterIiv, &args ))) WARN( "glTextureParameterIiv returned %#lx\n", status );
}

static void WINAPI glTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, const GLint *params )
{
    struct glTextureParameterIivEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, params %p\n", texture, target, pname, params );
    if ((status = UNIX_CALL( glTextureParameterIivEXT, &args ))) WARN( "glTextureParameterIivEXT returned %#lx\n", status );
}

static void WINAPI glTextureParameterIuiv( GLuint texture, GLenum pname, const GLuint *params )
{
    struct glTextureParameterIuiv_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, params %p\n", texture, pname, params );
    if ((status = UNIX_CALL( glTextureParameterIuiv, &args ))) WARN( "glTextureParameterIuiv returned %#lx\n", status );
}

static void WINAPI glTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, const GLuint *params )
{
    struct glTextureParameterIuivEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, params %p\n", texture, target, pname, params );
    if ((status = UNIX_CALL( glTextureParameterIuivEXT, &args ))) WARN( "glTextureParameterIuivEXT returned %#lx\n", status );
}

static void WINAPI glTextureParameterf( GLuint texture, GLenum pname, GLfloat param )
{
    struct glTextureParameterf_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, param %f\n", texture, pname, param );
    if ((status = UNIX_CALL( glTextureParameterf, &args ))) WARN( "glTextureParameterf returned %#lx\n", status );
}

static void WINAPI glTextureParameterfEXT( GLuint texture, GLenum target, GLenum pname, GLfloat param )
{
    struct glTextureParameterfEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, param %f\n", texture, target, pname, param );
    if ((status = UNIX_CALL( glTextureParameterfEXT, &args ))) WARN( "glTextureParameterfEXT returned %#lx\n", status );
}

static void WINAPI glTextureParameterfv( GLuint texture, GLenum pname, const GLfloat *param )
{
    struct glTextureParameterfv_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, param %p\n", texture, pname, param );
    if ((status = UNIX_CALL( glTextureParameterfv, &args ))) WARN( "glTextureParameterfv returned %#lx\n", status );
}

static void WINAPI glTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, const GLfloat *params )
{
    struct glTextureParameterfvEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, params %p\n", texture, target, pname, params );
    if ((status = UNIX_CALL( glTextureParameterfvEXT, &args ))) WARN( "glTextureParameterfvEXT returned %#lx\n", status );
}

static void WINAPI glTextureParameteri( GLuint texture, GLenum pname, GLint param )
{
    struct glTextureParameteri_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, param %d\n", texture, pname, param );
    if ((status = UNIX_CALL( glTextureParameteri, &args ))) WARN( "glTextureParameteri returned %#lx\n", status );
}

static void WINAPI glTextureParameteriEXT( GLuint texture, GLenum target, GLenum pname, GLint param )
{
    struct glTextureParameteriEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, param %d\n", texture, target, pname, param );
    if ((status = UNIX_CALL( glTextureParameteriEXT, &args ))) WARN( "glTextureParameteriEXT returned %#lx\n", status );
}

static void WINAPI glTextureParameteriv( GLuint texture, GLenum pname, const GLint *param )
{
    struct glTextureParameteriv_params args = { .teb = NtCurrentTeb(), .texture = texture, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "texture %d, pname %d, param %p\n", texture, pname, param );
    if ((status = UNIX_CALL( glTextureParameteriv, &args ))) WARN( "glTextureParameteriv returned %#lx\n", status );
}

static void WINAPI glTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, const GLint *params )
{
    struct glTextureParameterivEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "texture %d, target %d, pname %d, params %p\n", texture, target, pname, params );
    if ((status = UNIX_CALL( glTextureParameterivEXT, &args ))) WARN( "glTextureParameterivEXT returned %#lx\n", status );
}

static void WINAPI glTextureRangeAPPLE( GLenum target, GLsizei length, const void *pointer )
{
    struct glTextureRangeAPPLE_params args = { .teb = NtCurrentTeb(), .target = target, .length = length, .pointer = pointer };
    NTSTATUS status;
    TRACE( "target %d, length %d, pointer %p\n", target, length, pointer );
    if ((status = UNIX_CALL( glTextureRangeAPPLE, &args ))) WARN( "glTextureRangeAPPLE returned %#lx\n", status );
}

static void WINAPI glTextureRenderbufferEXT( GLuint texture, GLenum target, GLuint renderbuffer )
{
    struct glTextureRenderbufferEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .renderbuffer = renderbuffer };
    NTSTATUS status;
    TRACE( "texture %d, target %d, renderbuffer %d\n", texture, target, renderbuffer );
    if ((status = UNIX_CALL( glTextureRenderbufferEXT, &args ))) WARN( "glTextureRenderbufferEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorage1D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width )
{
    struct glTextureStorage1D_params args = { .teb = NtCurrentTeb(), .texture = texture, .levels = levels, .internalformat = internalformat, .width = width };
    NTSTATUS status;
    TRACE( "texture %d, levels %d, internalformat %d, width %d\n", texture, levels, internalformat, width );
    if ((status = UNIX_CALL( glTextureStorage1D, &args ))) WARN( "glTextureStorage1D returned %#lx\n", status );
}

static void WINAPI glTextureStorage1DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width )
{
    struct glTextureStorage1DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .levels = levels, .internalformat = internalformat, .width = width };
    NTSTATUS status;
    TRACE( "texture %d, target %d, levels %d, internalformat %d, width %d\n", texture, target, levels, internalformat, width );
    if ((status = UNIX_CALL( glTextureStorage1DEXT, &args ))) WARN( "glTextureStorage1DEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorage2D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glTextureStorage2D_params args = { .teb = NtCurrentTeb(), .texture = texture, .levels = levels, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "texture %d, levels %d, internalformat %d, width %d, height %d\n", texture, levels, internalformat, width, height );
    if ((status = UNIX_CALL( glTextureStorage2D, &args ))) WARN( "glTextureStorage2D returned %#lx\n", status );
}

static void WINAPI glTextureStorage2DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height )
{
    struct glTextureStorage2DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .levels = levels, .internalformat = internalformat, .width = width, .height = height };
    NTSTATUS status;
    TRACE( "texture %d, target %d, levels %d, internalformat %d, width %d, height %d\n", texture, target, levels, internalformat, width, height );
    if ((status = UNIX_CALL( glTextureStorage2DEXT, &args ))) WARN( "glTextureStorage2DEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorage2DMultisample( GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
{
    struct glTextureStorage2DMultisample_params args = { .teb = NtCurrentTeb(), .texture = texture, .samples = samples, .internalformat = internalformat, .width = width, .height = height, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "texture %d, samples %d, internalformat %d, width %d, height %d, fixedsamplelocations %d\n", texture, samples, internalformat, width, height, fixedsamplelocations );
    if ((status = UNIX_CALL( glTextureStorage2DMultisample, &args ))) WARN( "glTextureStorage2DMultisample returned %#lx\n", status );
}

static void WINAPI glTextureStorage2DMultisampleEXT( GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
{
    struct glTextureStorage2DMultisampleEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .samples = samples, .internalformat = internalformat, .width = width, .height = height, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "texture %d, target %d, samples %d, internalformat %d, width %d, height %d, fixedsamplelocations %d\n", texture, target, samples, internalformat, width, height, fixedsamplelocations );
    if ((status = UNIX_CALL( glTextureStorage2DMultisampleEXT, &args ))) WARN( "glTextureStorage2DMultisampleEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorage3D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth )
{
    struct glTextureStorage3D_params args = { .teb = NtCurrentTeb(), .texture = texture, .levels = levels, .internalformat = internalformat, .width = width, .height = height, .depth = depth };
    NTSTATUS status;
    TRACE( "texture %d, levels %d, internalformat %d, width %d, height %d, depth %d\n", texture, levels, internalformat, width, height, depth );
    if ((status = UNIX_CALL( glTextureStorage3D, &args ))) WARN( "glTextureStorage3D returned %#lx\n", status );
}

static void WINAPI glTextureStorage3DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth )
{
    struct glTextureStorage3DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .levels = levels, .internalformat = internalformat, .width = width, .height = height, .depth = depth };
    NTSTATUS status;
    TRACE( "texture %d, target %d, levels %d, internalformat %d, width %d, height %d, depth %d\n", texture, target, levels, internalformat, width, height, depth );
    if ((status = UNIX_CALL( glTextureStorage3DEXT, &args ))) WARN( "glTextureStorage3DEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorage3DMultisample( GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
{
    struct glTextureStorage3DMultisample_params args = { .teb = NtCurrentTeb(), .texture = texture, .samples = samples, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "texture %d, samples %d, internalformat %d, width %d, height %d, depth %d, fixedsamplelocations %d\n", texture, samples, internalformat, width, height, depth, fixedsamplelocations );
    if ((status = UNIX_CALL( glTextureStorage3DMultisample, &args ))) WARN( "glTextureStorage3DMultisample returned %#lx\n", status );
}

static void WINAPI glTextureStorage3DMultisampleEXT( GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
{
    struct glTextureStorage3DMultisampleEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .samples = samples, .internalformat = internalformat, .width = width, .height = height, .depth = depth, .fixedsamplelocations = fixedsamplelocations };
    NTSTATUS status;
    TRACE( "texture %d, target %d, samples %d, internalformat %d, width %d, height %d, depth %d, fixedsamplelocations %d\n", texture, target, samples, internalformat, width, height, depth, fixedsamplelocations );
    if ((status = UNIX_CALL( glTextureStorage3DMultisampleEXT, &args ))) WARN( "glTextureStorage3DMultisampleEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorageMem1DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset )
{
    struct glTextureStorageMem1DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .levels = levels, .internalFormat = internalFormat, .width = width, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "texture %d, levels %d, internalFormat %d, width %d, memory %d, offset %s\n", texture, levels, internalFormat, width, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTextureStorageMem1DEXT, &args ))) WARN( "glTextureStorageMem1DEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorageMem2DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset )
{
    struct glTextureStorageMem2DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .levels = levels, .internalFormat = internalFormat, .width = width, .height = height, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "texture %d, levels %d, internalFormat %d, width %d, height %d, memory %d, offset %s\n", texture, levels, internalFormat, width, height, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTextureStorageMem2DEXT, &args ))) WARN( "glTextureStorageMem2DEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorageMem2DMultisampleEXT( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset )
{
    struct glTextureStorageMem2DMultisampleEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .samples = samples, .internalFormat = internalFormat, .width = width, .height = height, .fixedSampleLocations = fixedSampleLocations, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "texture %d, samples %d, internalFormat %d, width %d, height %d, fixedSampleLocations %d, memory %d, offset %s\n", texture, samples, internalFormat, width, height, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTextureStorageMem2DMultisampleEXT, &args ))) WARN( "glTextureStorageMem2DMultisampleEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorageMem3DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset )
{
    struct glTextureStorageMem3DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .levels = levels, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "texture %d, levels %d, internalFormat %d, width %d, height %d, depth %d, memory %d, offset %s\n", texture, levels, internalFormat, width, height, depth, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTextureStorageMem3DEXT, &args ))) WARN( "glTextureStorageMem3DEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorageMem3DMultisampleEXT( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset )
{
    struct glTextureStorageMem3DMultisampleEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .samples = samples, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .fixedSampleLocations = fixedSampleLocations, .memory = memory, .offset = offset };
    NTSTATUS status;
    TRACE( "texture %d, samples %d, internalFormat %d, width %d, height %d, depth %d, fixedSampleLocations %d, memory %d, offset %s\n", texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
    if ((status = UNIX_CALL( glTextureStorageMem3DMultisampleEXT, &args ))) WARN( "glTextureStorageMem3DMultisampleEXT returned %#lx\n", status );
}

static void WINAPI glTextureStorageSparseAMD( GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags )
{
    struct glTextureStorageSparseAMD_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .internalFormat = internalFormat, .width = width, .height = height, .depth = depth, .layers = layers, .flags = flags };
    NTSTATUS status;
    TRACE( "texture %d, target %d, internalFormat %d, width %d, height %d, depth %d, layers %d, flags %d\n", texture, target, internalFormat, width, height, depth, layers, flags );
    if ((status = UNIX_CALL( glTextureStorageSparseAMD, &args ))) WARN( "glTextureStorageSparseAMD returned %#lx\n", status );
}

static void WINAPI glTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureSubImage1D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .width = width, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, width %d, format %d, type %d, pixels %p\n", texture, level, xoffset, width, format, type, pixels );
    if ((status = UNIX_CALL( glTextureSubImage1D, &args ))) WARN( "glTextureSubImage1D returned %#lx\n", status );
}

static void WINAPI glTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureSubImage1DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, width %d, format %d, type %d, pixels %p\n", texture, target, level, xoffset, width, format, type, pixels );
    if ((status = UNIX_CALL( glTextureSubImage1DEXT, &args ))) WARN( "glTextureSubImage1DEXT returned %#lx\n", status );
}

static void WINAPI glTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureSubImage2D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, type %d, pixels %p\n", texture, level, xoffset, yoffset, width, height, format, type, pixels );
    if ((status = UNIX_CALL( glTextureSubImage2D, &args ))) WARN( "glTextureSubImage2D returned %#lx\n", status );
}

static void WINAPI glTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureSubImage2DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, type %d, pixels %p\n", texture, target, level, xoffset, yoffset, width, height, format, type, pixels );
    if ((status = UNIX_CALL( glTextureSubImage2DEXT, &args ))) WARN( "glTextureSubImage2DEXT returned %#lx\n", status );
}

static void WINAPI glTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureSubImage3D_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, type %d, pixels %p\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
    if ((status = UNIX_CALL( glTextureSubImage3D, &args ))) WARN( "glTextureSubImage3D returned %#lx\n", status );
}

static void WINAPI glTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
{
    struct glTextureSubImage3DEXT_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .zoffset = zoffset, .width = width, .height = height, .depth = depth, .format = format, .type = type, .pixels = pixels };
    NTSTATUS status;
    TRACE( "texture %d, target %d, level %d, xoffset %d, yoffset %d, zoffset %d, width %d, height %d, depth %d, format %d, type %d, pixels %p\n", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
    if ((status = UNIX_CALL( glTextureSubImage3DEXT, &args ))) WARN( "glTextureSubImage3DEXT returned %#lx\n", status );
}

static void WINAPI glTextureView( GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers )
{
    struct glTextureView_params args = { .teb = NtCurrentTeb(), .texture = texture, .target = target, .origtexture = origtexture, .internalformat = internalformat, .minlevel = minlevel, .numlevels = numlevels, .minlayer = minlayer, .numlayers = numlayers };
    NTSTATUS status;
    TRACE( "texture %d, target %d, origtexture %d, internalformat %d, minlevel %d, numlevels %d, minlayer %d, numlayers %d\n", texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers );
    if ((status = UNIX_CALL( glTextureView, &args ))) WARN( "glTextureView returned %#lx\n", status );
}

static void WINAPI glTrackMatrixNV( GLenum target, GLuint address, GLenum matrix, GLenum transform )
{
    struct glTrackMatrixNV_params args = { .teb = NtCurrentTeb(), .target = target, .address = address, .matrix = matrix, .transform = transform };
    NTSTATUS status;
    TRACE( "target %d, address %d, matrix %d, transform %d\n", target, address, matrix, transform );
    if ((status = UNIX_CALL( glTrackMatrixNV, &args ))) WARN( "glTrackMatrixNV returned %#lx\n", status );
}

static void WINAPI glTransformFeedbackAttribsNV( GLsizei count, const GLint *attribs, GLenum bufferMode )
{
    struct glTransformFeedbackAttribsNV_params args = { .teb = NtCurrentTeb(), .count = count, .attribs = attribs, .bufferMode = bufferMode };
    NTSTATUS status;
    TRACE( "count %d, attribs %p, bufferMode %d\n", count, attribs, bufferMode );
    if ((status = UNIX_CALL( glTransformFeedbackAttribsNV, &args ))) WARN( "glTransformFeedbackAttribsNV returned %#lx\n", status );
}

static void WINAPI glTransformFeedbackBufferBase( GLuint xfb, GLuint index, GLuint buffer )
{
    struct glTransformFeedbackBufferBase_params args = { .teb = NtCurrentTeb(), .xfb = xfb, .index = index, .buffer = buffer };
    NTSTATUS status;
    TRACE( "xfb %d, index %d, buffer %d\n", xfb, index, buffer );
    if ((status = UNIX_CALL( glTransformFeedbackBufferBase, &args ))) WARN( "glTransformFeedbackBufferBase returned %#lx\n", status );
}

static void WINAPI glTransformFeedbackBufferRange( GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
{
    struct glTransformFeedbackBufferRange_params args = { .teb = NtCurrentTeb(), .xfb = xfb, .index = index, .buffer = buffer, .offset = offset, .size = size };
    NTSTATUS status;
    TRACE( "xfb %d, index %d, buffer %d, offset %Id, size %Id\n", xfb, index, buffer, offset, size );
    if ((status = UNIX_CALL( glTransformFeedbackBufferRange, &args ))) WARN( "glTransformFeedbackBufferRange returned %#lx\n", status );
}

static void WINAPI glTransformFeedbackStreamAttribsNV( GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode )
{
    struct glTransformFeedbackStreamAttribsNV_params args = { .teb = NtCurrentTeb(), .count = count, .attribs = attribs, .nbuffers = nbuffers, .bufstreams = bufstreams, .bufferMode = bufferMode };
    NTSTATUS status;
    TRACE( "count %d, attribs %p, nbuffers %d, bufstreams %p, bufferMode %d\n", count, attribs, nbuffers, bufstreams, bufferMode );
    if ((status = UNIX_CALL( glTransformFeedbackStreamAttribsNV, &args ))) WARN( "glTransformFeedbackStreamAttribsNV returned %#lx\n", status );
}

static void WINAPI glTransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode )
{
    struct glTransformFeedbackVaryings_params args = { .teb = NtCurrentTeb(), .program = program, .count = count, .varyings = varyings, .bufferMode = bufferMode };
    NTSTATUS status;
    TRACE( "program %d, count %d, varyings %p, bufferMode %d\n", program, count, varyings, bufferMode );
    if ((status = UNIX_CALL( glTransformFeedbackVaryings, &args ))) WARN( "glTransformFeedbackVaryings returned %#lx\n", status );
}

static void WINAPI glTransformFeedbackVaryingsEXT( GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode )
{
    struct glTransformFeedbackVaryingsEXT_params args = { .teb = NtCurrentTeb(), .program = program, .count = count, .varyings = varyings, .bufferMode = bufferMode };
    NTSTATUS status;
    TRACE( "program %d, count %d, varyings %p, bufferMode %d\n", program, count, varyings, bufferMode );
    if ((status = UNIX_CALL( glTransformFeedbackVaryingsEXT, &args ))) WARN( "glTransformFeedbackVaryingsEXT returned %#lx\n", status );
}

static void WINAPI glTransformFeedbackVaryingsNV( GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode )
{
    struct glTransformFeedbackVaryingsNV_params args = { .teb = NtCurrentTeb(), .program = program, .count = count, .locations = locations, .bufferMode = bufferMode };
    NTSTATUS status;
    TRACE( "program %d, count %d, locations %p, bufferMode %d\n", program, count, locations, bufferMode );
    if ((status = UNIX_CALL( glTransformFeedbackVaryingsNV, &args ))) WARN( "glTransformFeedbackVaryingsNV returned %#lx\n", status );
}

static void WINAPI glTransformPathNV( GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat *transformValues )
{
    struct glTransformPathNV_params args = { .teb = NtCurrentTeb(), .resultPath = resultPath, .srcPath = srcPath, .transformType = transformType, .transformValues = transformValues };
    NTSTATUS status;
    TRACE( "resultPath %d, srcPath %d, transformType %d, transformValues %p\n", resultPath, srcPath, transformType, transformValues );
    if ((status = UNIX_CALL( glTransformPathNV, &args ))) WARN( "glTransformPathNV returned %#lx\n", status );
}

static void WINAPI glTranslatexOES( GLfixed x, GLfixed y, GLfixed z )
{
    struct glTranslatexOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glTranslatexOES, &args ))) WARN( "glTranslatexOES returned %#lx\n", status );
}

static void WINAPI glUniform1d( GLint location, GLdouble x )
{
    struct glUniform1d_params args = { .teb = NtCurrentTeb(), .location = location, .x = x };
    NTSTATUS status;
    TRACE( "location %d, x %f\n", location, x );
    if ((status = UNIX_CALL( glUniform1d, &args ))) WARN( "glUniform1d returned %#lx\n", status );
}

static void WINAPI glUniform1dv( GLint location, GLsizei count, const GLdouble *value )
{
    struct glUniform1dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1dv, &args ))) WARN( "glUniform1dv returned %#lx\n", status );
}

static void WINAPI glUniform1f( GLint location, GLfloat v0 )
{
    struct glUniform1f_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "location %d, v0 %f\n", location, v0 );
    if ((status = UNIX_CALL( glUniform1f, &args ))) WARN( "glUniform1f returned %#lx\n", status );
}

static void WINAPI glUniform1fARB( GLint location, GLfloat v0 )
{
    struct glUniform1fARB_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "location %d, v0 %f\n", location, v0 );
    if ((status = UNIX_CALL( glUniform1fARB, &args ))) WARN( "glUniform1fARB returned %#lx\n", status );
}

static void WINAPI glUniform1fv( GLint location, GLsizei count, const GLfloat *value )
{
    struct glUniform1fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1fv, &args ))) WARN( "glUniform1fv returned %#lx\n", status );
}

static void WINAPI glUniform1fvARB( GLint location, GLsizei count, const GLfloat *value )
{
    struct glUniform1fvARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1fvARB, &args ))) WARN( "glUniform1fvARB returned %#lx\n", status );
}

static void WINAPI glUniform1i( GLint location, GLint v0 )
{
    struct glUniform1i_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d\n", location, v0 );
    if ((status = UNIX_CALL( glUniform1i, &args ))) WARN( "glUniform1i returned %#lx\n", status );
}

static void WINAPI glUniform1i64ARB( GLint location, GLint64 x )
{
    struct glUniform1i64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .x = x };
    NTSTATUS status;
    TRACE( "location %d, x %s\n", location, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glUniform1i64ARB, &args ))) WARN( "glUniform1i64ARB returned %#lx\n", status );
}

static void WINAPI glUniform1i64NV( GLint location, GLint64EXT x )
{
    struct glUniform1i64NV_params args = { .teb = NtCurrentTeb(), .location = location, .x = x };
    NTSTATUS status;
    TRACE( "location %d, x %s\n", location, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glUniform1i64NV, &args ))) WARN( "glUniform1i64NV returned %#lx\n", status );
}

static void WINAPI glUniform1i64vARB( GLint location, GLsizei count, const GLint64 *value )
{
    struct glUniform1i64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1i64vARB, &args ))) WARN( "glUniform1i64vARB returned %#lx\n", status );
}

static void WINAPI glUniform1i64vNV( GLint location, GLsizei count, const GLint64EXT *value )
{
    struct glUniform1i64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1i64vNV, &args ))) WARN( "glUniform1i64vNV returned %#lx\n", status );
}

static void WINAPI glUniform1iARB( GLint location, GLint v0 )
{
    struct glUniform1iARB_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d\n", location, v0 );
    if ((status = UNIX_CALL( glUniform1iARB, &args ))) WARN( "glUniform1iARB returned %#lx\n", status );
}

static void WINAPI glUniform1iv( GLint location, GLsizei count, const GLint *value )
{
    struct glUniform1iv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1iv, &args ))) WARN( "glUniform1iv returned %#lx\n", status );
}

static void WINAPI glUniform1ivARB( GLint location, GLsizei count, const GLint *value )
{
    struct glUniform1ivARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1ivARB, &args ))) WARN( "glUniform1ivARB returned %#lx\n", status );
}

static void WINAPI glUniform1ui( GLint location, GLuint v0 )
{
    struct glUniform1ui_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d\n", location, v0 );
    if ((status = UNIX_CALL( glUniform1ui, &args ))) WARN( "glUniform1ui returned %#lx\n", status );
}

static void WINAPI glUniform1ui64ARB( GLint location, GLuint64 x )
{
    struct glUniform1ui64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .x = x };
    NTSTATUS status;
    TRACE( "location %d, x %s\n", location, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glUniform1ui64ARB, &args ))) WARN( "glUniform1ui64ARB returned %#lx\n", status );
}

static void WINAPI glUniform1ui64NV( GLint location, GLuint64EXT x )
{
    struct glUniform1ui64NV_params args = { .teb = NtCurrentTeb(), .location = location, .x = x };
    NTSTATUS status;
    TRACE( "location %d, x %s\n", location, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glUniform1ui64NV, &args ))) WARN( "glUniform1ui64NV returned %#lx\n", status );
}

static void WINAPI glUniform1ui64vARB( GLint location, GLsizei count, const GLuint64 *value )
{
    struct glUniform1ui64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1ui64vARB, &args ))) WARN( "glUniform1ui64vARB returned %#lx\n", status );
}

static void WINAPI glUniform1ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glUniform1ui64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1ui64vNV, &args ))) WARN( "glUniform1ui64vNV returned %#lx\n", status );
}

static void WINAPI glUniform1uiEXT( GLint location, GLuint v0 )
{
    struct glUniform1uiEXT_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d\n", location, v0 );
    if ((status = UNIX_CALL( glUniform1uiEXT, &args ))) WARN( "glUniform1uiEXT returned %#lx\n", status );
}

static void WINAPI glUniform1uiv( GLint location, GLsizei count, const GLuint *value )
{
    struct glUniform1uiv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1uiv, &args ))) WARN( "glUniform1uiv returned %#lx\n", status );
}

static void WINAPI glUniform1uivEXT( GLint location, GLsizei count, const GLuint *value )
{
    struct glUniform1uivEXT_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform1uivEXT, &args ))) WARN( "glUniform1uivEXT returned %#lx\n", status );
}

static void WINAPI glUniform2d( GLint location, GLdouble x, GLdouble y )
{
    struct glUniform2d_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "location %d, x %f, y %f\n", location, x, y );
    if ((status = UNIX_CALL( glUniform2d, &args ))) WARN( "glUniform2d returned %#lx\n", status );
}

static void WINAPI glUniform2dv( GLint location, GLsizei count, const GLdouble *value )
{
    struct glUniform2dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2dv, &args ))) WARN( "glUniform2dv returned %#lx\n", status );
}

static void WINAPI glUniform2f( GLint location, GLfloat v0, GLfloat v1 )
{
    struct glUniform2f_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "location %d, v0 %f, v1 %f\n", location, v0, v1 );
    if ((status = UNIX_CALL( glUniform2f, &args ))) WARN( "glUniform2f returned %#lx\n", status );
}

static void WINAPI glUniform2fARB( GLint location, GLfloat v0, GLfloat v1 )
{
    struct glUniform2fARB_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "location %d, v0 %f, v1 %f\n", location, v0, v1 );
    if ((status = UNIX_CALL( glUniform2fARB, &args ))) WARN( "glUniform2fARB returned %#lx\n", status );
}

static void WINAPI glUniform2fv( GLint location, GLsizei count, const GLfloat *value )
{
    struct glUniform2fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2fv, &args ))) WARN( "glUniform2fv returned %#lx\n", status );
}

static void WINAPI glUniform2fvARB( GLint location, GLsizei count, const GLfloat *value )
{
    struct glUniform2fvARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2fvARB, &args ))) WARN( "glUniform2fvARB returned %#lx\n", status );
}

static void WINAPI glUniform2i( GLint location, GLint v0, GLint v1 )
{
    struct glUniform2i_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d\n", location, v0, v1 );
    if ((status = UNIX_CALL( glUniform2i, &args ))) WARN( "glUniform2i returned %#lx\n", status );
}

static void WINAPI glUniform2i64ARB( GLint location, GLint64 x, GLint64 y )
{
    struct glUniform2i64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glUniform2i64ARB, &args ))) WARN( "glUniform2i64ARB returned %#lx\n", status );
}

static void WINAPI glUniform2i64NV( GLint location, GLint64EXT x, GLint64EXT y )
{
    struct glUniform2i64NV_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glUniform2i64NV, &args ))) WARN( "glUniform2i64NV returned %#lx\n", status );
}

static void WINAPI glUniform2i64vARB( GLint location, GLsizei count, const GLint64 *value )
{
    struct glUniform2i64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2i64vARB, &args ))) WARN( "glUniform2i64vARB returned %#lx\n", status );
}

static void WINAPI glUniform2i64vNV( GLint location, GLsizei count, const GLint64EXT *value )
{
    struct glUniform2i64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2i64vNV, &args ))) WARN( "glUniform2i64vNV returned %#lx\n", status );
}

static void WINAPI glUniform2iARB( GLint location, GLint v0, GLint v1 )
{
    struct glUniform2iARB_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d\n", location, v0, v1 );
    if ((status = UNIX_CALL( glUniform2iARB, &args ))) WARN( "glUniform2iARB returned %#lx\n", status );
}

static void WINAPI glUniform2iv( GLint location, GLsizei count, const GLint *value )
{
    struct glUniform2iv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2iv, &args ))) WARN( "glUniform2iv returned %#lx\n", status );
}

static void WINAPI glUniform2ivARB( GLint location, GLsizei count, const GLint *value )
{
    struct glUniform2ivARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2ivARB, &args ))) WARN( "glUniform2ivARB returned %#lx\n", status );
}

static void WINAPI glUniform2ui( GLint location, GLuint v0, GLuint v1 )
{
    struct glUniform2ui_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d\n", location, v0, v1 );
    if ((status = UNIX_CALL( glUniform2ui, &args ))) WARN( "glUniform2ui returned %#lx\n", status );
}

static void WINAPI glUniform2ui64ARB( GLint location, GLuint64 x, GLuint64 y )
{
    struct glUniform2ui64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glUniform2ui64ARB, &args ))) WARN( "glUniform2ui64ARB returned %#lx\n", status );
}

static void WINAPI glUniform2ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y )
{
    struct glUniform2ui64NV_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glUniform2ui64NV, &args ))) WARN( "glUniform2ui64NV returned %#lx\n", status );
}

static void WINAPI glUniform2ui64vARB( GLint location, GLsizei count, const GLuint64 *value )
{
    struct glUniform2ui64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2ui64vARB, &args ))) WARN( "glUniform2ui64vARB returned %#lx\n", status );
}

static void WINAPI glUniform2ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glUniform2ui64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2ui64vNV, &args ))) WARN( "glUniform2ui64vNV returned %#lx\n", status );
}

static void WINAPI glUniform2uiEXT( GLint location, GLuint v0, GLuint v1 )
{
    struct glUniform2uiEXT_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d\n", location, v0, v1 );
    if ((status = UNIX_CALL( glUniform2uiEXT, &args ))) WARN( "glUniform2uiEXT returned %#lx\n", status );
}

static void WINAPI glUniform2uiv( GLint location, GLsizei count, const GLuint *value )
{
    struct glUniform2uiv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2uiv, &args ))) WARN( "glUniform2uiv returned %#lx\n", status );
}

static void WINAPI glUniform2uivEXT( GLint location, GLsizei count, const GLuint *value )
{
    struct glUniform2uivEXT_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform2uivEXT, &args ))) WARN( "glUniform2uivEXT returned %#lx\n", status );
}

static void WINAPI glUniform3d( GLint location, GLdouble x, GLdouble y, GLdouble z )
{
    struct glUniform3d_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "location %d, x %f, y %f, z %f\n", location, x, y, z );
    if ((status = UNIX_CALL( glUniform3d, &args ))) WARN( "glUniform3d returned %#lx\n", status );
}

static void WINAPI glUniform3dv( GLint location, GLsizei count, const GLdouble *value )
{
    struct glUniform3dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3dv, &args ))) WARN( "glUniform3dv returned %#lx\n", status );
}

static void WINAPI glUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
{
    struct glUniform3f_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "location %d, v0 %f, v1 %f, v2 %f\n", location, v0, v1, v2 );
    if ((status = UNIX_CALL( glUniform3f, &args ))) WARN( "glUniform3f returned %#lx\n", status );
}

static void WINAPI glUniform3fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
{
    struct glUniform3fARB_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "location %d, v0 %f, v1 %f, v2 %f\n", location, v0, v1, v2 );
    if ((status = UNIX_CALL( glUniform3fARB, &args ))) WARN( "glUniform3fARB returned %#lx\n", status );
}

static void WINAPI glUniform3fv( GLint location, GLsizei count, const GLfloat *value )
{
    struct glUniform3fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3fv, &args ))) WARN( "glUniform3fv returned %#lx\n", status );
}

static void WINAPI glUniform3fvARB( GLint location, GLsizei count, const GLfloat *value )
{
    struct glUniform3fvARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3fvARB, &args ))) WARN( "glUniform3fvARB returned %#lx\n", status );
}

static void WINAPI glUniform3i( GLint location, GLint v0, GLint v1, GLint v2 )
{
    struct glUniform3i_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d, v2 %d\n", location, v0, v1, v2 );
    if ((status = UNIX_CALL( glUniform3i, &args ))) WARN( "glUniform3i returned %#lx\n", status );
}

static void WINAPI glUniform3i64ARB( GLint location, GLint64 x, GLint64 y, GLint64 z )
{
    struct glUniform3i64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s, z %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glUniform3i64ARB, &args ))) WARN( "glUniform3i64ARB returned %#lx\n", status );
}

static void WINAPI glUniform3i64NV( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z )
{
    struct glUniform3i64NV_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s, z %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glUniform3i64NV, &args ))) WARN( "glUniform3i64NV returned %#lx\n", status );
}

static void WINAPI glUniform3i64vARB( GLint location, GLsizei count, const GLint64 *value )
{
    struct glUniform3i64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3i64vARB, &args ))) WARN( "glUniform3i64vARB returned %#lx\n", status );
}

static void WINAPI glUniform3i64vNV( GLint location, GLsizei count, const GLint64EXT *value )
{
    struct glUniform3i64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3i64vNV, &args ))) WARN( "glUniform3i64vNV returned %#lx\n", status );
}

static void WINAPI glUniform3iARB( GLint location, GLint v0, GLint v1, GLint v2 )
{
    struct glUniform3iARB_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d, v2 %d\n", location, v0, v1, v2 );
    if ((status = UNIX_CALL( glUniform3iARB, &args ))) WARN( "glUniform3iARB returned %#lx\n", status );
}

static void WINAPI glUniform3iv( GLint location, GLsizei count, const GLint *value )
{
    struct glUniform3iv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3iv, &args ))) WARN( "glUniform3iv returned %#lx\n", status );
}

static void WINAPI glUniform3ivARB( GLint location, GLsizei count, const GLint *value )
{
    struct glUniform3ivARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3ivARB, &args ))) WARN( "glUniform3ivARB returned %#lx\n", status );
}

static void WINAPI glUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 )
{
    struct glUniform3ui_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d, v2 %d\n", location, v0, v1, v2 );
    if ((status = UNIX_CALL( glUniform3ui, &args ))) WARN( "glUniform3ui returned %#lx\n", status );
}

static void WINAPI glUniform3ui64ARB( GLint location, GLuint64 x, GLuint64 y, GLuint64 z )
{
    struct glUniform3ui64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s, z %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glUniform3ui64ARB, &args ))) WARN( "glUniform3ui64ARB returned %#lx\n", status );
}

static void WINAPI glUniform3ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z )
{
    struct glUniform3ui64NV_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s, z %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glUniform3ui64NV, &args ))) WARN( "glUniform3ui64NV returned %#lx\n", status );
}

static void WINAPI glUniform3ui64vARB( GLint location, GLsizei count, const GLuint64 *value )
{
    struct glUniform3ui64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3ui64vARB, &args ))) WARN( "glUniform3ui64vARB returned %#lx\n", status );
}

static void WINAPI glUniform3ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glUniform3ui64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3ui64vNV, &args ))) WARN( "glUniform3ui64vNV returned %#lx\n", status );
}

static void WINAPI glUniform3uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2 )
{
    struct glUniform3uiEXT_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d, v2 %d\n", location, v0, v1, v2 );
    if ((status = UNIX_CALL( glUniform3uiEXT, &args ))) WARN( "glUniform3uiEXT returned %#lx\n", status );
}

static void WINAPI glUniform3uiv( GLint location, GLsizei count, const GLuint *value )
{
    struct glUniform3uiv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3uiv, &args ))) WARN( "glUniform3uiv returned %#lx\n", status );
}

static void WINAPI glUniform3uivEXT( GLint location, GLsizei count, const GLuint *value )
{
    struct glUniform3uivEXT_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform3uivEXT, &args ))) WARN( "glUniform3uivEXT returned %#lx\n", status );
}

static void WINAPI glUniform4d( GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glUniform4d_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "location %d, x %f, y %f, z %f, w %f\n", location, x, y, z, w );
    if ((status = UNIX_CALL( glUniform4d, &args ))) WARN( "glUniform4d returned %#lx\n", status );
}

static void WINAPI glUniform4dv( GLint location, GLsizei count, const GLdouble *value )
{
    struct glUniform4dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4dv, &args ))) WARN( "glUniform4dv returned %#lx\n", status );
}

static void WINAPI glUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
{
    struct glUniform4f_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "location %d, v0 %f, v1 %f, v2 %f, v3 %f\n", location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glUniform4f, &args ))) WARN( "glUniform4f returned %#lx\n", status );
}

static void WINAPI glUniform4fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
{
    struct glUniform4fARB_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "location %d, v0 %f, v1 %f, v2 %f, v3 %f\n", location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glUniform4fARB, &args ))) WARN( "glUniform4fARB returned %#lx\n", status );
}

static void WINAPI glUniform4fv( GLint location, GLsizei count, const GLfloat *value )
{
    struct glUniform4fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4fv, &args ))) WARN( "glUniform4fv returned %#lx\n", status );
}

static void WINAPI glUniform4fvARB( GLint location, GLsizei count, const GLfloat *value )
{
    struct glUniform4fvARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4fvARB, &args ))) WARN( "glUniform4fvARB returned %#lx\n", status );
}

static void WINAPI glUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
{
    struct glUniform4i_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d, v2 %d, v3 %d\n", location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glUniform4i, &args ))) WARN( "glUniform4i returned %#lx\n", status );
}

static void WINAPI glUniform4i64ARB( GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w )
{
    struct glUniform4i64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s, z %s, w %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glUniform4i64ARB, &args ))) WARN( "glUniform4i64ARB returned %#lx\n", status );
}

static void WINAPI glUniform4i64NV( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w )
{
    struct glUniform4i64NV_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s, z %s, w %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glUniform4i64NV, &args ))) WARN( "glUniform4i64NV returned %#lx\n", status );
}

static void WINAPI glUniform4i64vARB( GLint location, GLsizei count, const GLint64 *value )
{
    struct glUniform4i64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4i64vARB, &args ))) WARN( "glUniform4i64vARB returned %#lx\n", status );
}

static void WINAPI glUniform4i64vNV( GLint location, GLsizei count, const GLint64EXT *value )
{
    struct glUniform4i64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4i64vNV, &args ))) WARN( "glUniform4i64vNV returned %#lx\n", status );
}

static void WINAPI glUniform4iARB( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
{
    struct glUniform4iARB_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d, v2 %d, v3 %d\n", location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glUniform4iARB, &args ))) WARN( "glUniform4iARB returned %#lx\n", status );
}

static void WINAPI glUniform4iv( GLint location, GLsizei count, const GLint *value )
{
    struct glUniform4iv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4iv, &args ))) WARN( "glUniform4iv returned %#lx\n", status );
}

static void WINAPI glUniform4ivARB( GLint location, GLsizei count, const GLint *value )
{
    struct glUniform4ivARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4ivARB, &args ))) WARN( "glUniform4ivARB returned %#lx\n", status );
}

static void WINAPI glUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
{
    struct glUniform4ui_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d, v2 %d, v3 %d\n", location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glUniform4ui, &args ))) WARN( "glUniform4ui returned %#lx\n", status );
}

static void WINAPI glUniform4ui64ARB( GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w )
{
    struct glUniform4ui64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s, z %s, w %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glUniform4ui64ARB, &args ))) WARN( "glUniform4ui64ARB returned %#lx\n", status );
}

static void WINAPI glUniform4ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w )
{
    struct glUniform4ui64NV_params args = { .teb = NtCurrentTeb(), .location = location, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "location %d, x %s, y %s, z %s, w %s\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glUniform4ui64NV, &args ))) WARN( "glUniform4ui64NV returned %#lx\n", status );
}

static void WINAPI glUniform4ui64vARB( GLint location, GLsizei count, const GLuint64 *value )
{
    struct glUniform4ui64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4ui64vARB, &args ))) WARN( "glUniform4ui64vARB returned %#lx\n", status );
}

static void WINAPI glUniform4ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glUniform4ui64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4ui64vNV, &args ))) WARN( "glUniform4ui64vNV returned %#lx\n", status );
}

static void WINAPI glUniform4uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
{
    struct glUniform4uiEXT_params args = { .teb = NtCurrentTeb(), .location = location, .v0 = v0, .v1 = v1, .v2 = v2, .v3 = v3 };
    NTSTATUS status;
    TRACE( "location %d, v0 %d, v1 %d, v2 %d, v3 %d\n", location, v0, v1, v2, v3 );
    if ((status = UNIX_CALL( glUniform4uiEXT, &args ))) WARN( "glUniform4uiEXT returned %#lx\n", status );
}

static void WINAPI glUniform4uiv( GLint location, GLsizei count, const GLuint *value )
{
    struct glUniform4uiv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4uiv, &args ))) WARN( "glUniform4uiv returned %#lx\n", status );
}

static void WINAPI glUniform4uivEXT( GLint location, GLsizei count, const GLuint *value )
{
    struct glUniform4uivEXT_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniform4uivEXT, &args ))) WARN( "glUniform4uivEXT returned %#lx\n", status );
}

static void WINAPI glUniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding )
{
    struct glUniformBlockBinding_params args = { .teb = NtCurrentTeb(), .program = program, .uniformBlockIndex = uniformBlockIndex, .uniformBlockBinding = uniformBlockBinding };
    NTSTATUS status;
    TRACE( "program %d, uniformBlockIndex %d, uniformBlockBinding %d\n", program, uniformBlockIndex, uniformBlockBinding );
    if ((status = UNIX_CALL( glUniformBlockBinding, &args ))) WARN( "glUniformBlockBinding returned %#lx\n", status );
}

static void WINAPI glUniformBufferEXT( GLuint program, GLint location, GLuint buffer )
{
    struct glUniformBufferEXT_params args = { .teb = NtCurrentTeb(), .program = program, .location = location, .buffer = buffer };
    NTSTATUS status;
    TRACE( "program %d, location %d, buffer %d\n", program, location, buffer );
    if ((status = UNIX_CALL( glUniformBufferEXT, &args ))) WARN( "glUniformBufferEXT returned %#lx\n", status );
}

static void WINAPI glUniformHandleui64ARB( GLint location, GLuint64 value )
{
    struct glUniformHandleui64ARB_params args = { .teb = NtCurrentTeb(), .location = location, .value = value };
    NTSTATUS status;
    TRACE( "location %d, value %s\n", location, wine_dbgstr_longlong(value) );
    if ((status = UNIX_CALL( glUniformHandleui64ARB, &args ))) WARN( "glUniformHandleui64ARB returned %#lx\n", status );
}

static void WINAPI glUniformHandleui64NV( GLint location, GLuint64 value )
{
    struct glUniformHandleui64NV_params args = { .teb = NtCurrentTeb(), .location = location, .value = value };
    NTSTATUS status;
    TRACE( "location %d, value %s\n", location, wine_dbgstr_longlong(value) );
    if ((status = UNIX_CALL( glUniformHandleui64NV, &args ))) WARN( "glUniformHandleui64NV returned %#lx\n", status );
}

static void WINAPI glUniformHandleui64vARB( GLint location, GLsizei count, const GLuint64 *value )
{
    struct glUniformHandleui64vARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniformHandleui64vARB, &args ))) WARN( "glUniformHandleui64vARB returned %#lx\n", status );
}

static void WINAPI glUniformHandleui64vNV( GLint location, GLsizei count, const GLuint64 *value )
{
    struct glUniformHandleui64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniformHandleui64vNV, &args ))) WARN( "glUniformHandleui64vNV returned %#lx\n", status );
}

static void WINAPI glUniformMatrix2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix2dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix2dv, &args ))) WARN( "glUniformMatrix2dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix2fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix2fv, &args ))) WARN( "glUniformMatrix2fv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix2fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix2fvARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix2fvARB, &args ))) WARN( "glUniformMatrix2fvARB returned %#lx\n", status );
}

static void WINAPI glUniformMatrix2x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix2x3dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix2x3dv, &args ))) WARN( "glUniformMatrix2x3dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix2x3fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix2x3fv, &args ))) WARN( "glUniformMatrix2x3fv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix2x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix2x4dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix2x4dv, &args ))) WARN( "glUniformMatrix2x4dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix2x4fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix2x4fv, &args ))) WARN( "glUniformMatrix2x4fv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix3dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix3dv, &args ))) WARN( "glUniformMatrix3dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix3fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix3fv, &args ))) WARN( "glUniformMatrix3fv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix3fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix3fvARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix3fvARB, &args ))) WARN( "glUniformMatrix3fvARB returned %#lx\n", status );
}

static void WINAPI glUniformMatrix3x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix3x2dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix3x2dv, &args ))) WARN( "glUniformMatrix3x2dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix3x2fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix3x2fv, &args ))) WARN( "glUniformMatrix3x2fv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix3x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix3x4dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix3x4dv, &args ))) WARN( "glUniformMatrix3x4dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix3x4fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix3x4fv, &args ))) WARN( "glUniformMatrix3x4fv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix4dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix4dv, &args ))) WARN( "glUniformMatrix4dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix4fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix4fv, &args ))) WARN( "glUniformMatrix4fv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix4fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix4fvARB_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix4fvARB, &args ))) WARN( "glUniformMatrix4fvARB returned %#lx\n", status );
}

static void WINAPI glUniformMatrix4x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix4x2dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix4x2dv, &args ))) WARN( "glUniformMatrix4x2dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix4x2fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix4x2fv, &args ))) WARN( "glUniformMatrix4x2fv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix4x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
{
    struct glUniformMatrix4x3dv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix4x3dv, &args ))) WARN( "glUniformMatrix4x3dv returned %#lx\n", status );
}

static void WINAPI glUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
{
    struct glUniformMatrix4x3fv_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .transpose = transpose, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, transpose %d, value %p\n", location, count, transpose, value );
    if ((status = UNIX_CALL( glUniformMatrix4x3fv, &args ))) WARN( "glUniformMatrix4x3fv returned %#lx\n", status );
}

static void WINAPI glUniformSubroutinesuiv( GLenum shadertype, GLsizei count, const GLuint *indices )
{
    struct glUniformSubroutinesuiv_params args = { .teb = NtCurrentTeb(), .shadertype = shadertype, .count = count, .indices = indices };
    NTSTATUS status;
    TRACE( "shadertype %d, count %d, indices %p\n", shadertype, count, indices );
    if ((status = UNIX_CALL( glUniformSubroutinesuiv, &args ))) WARN( "glUniformSubroutinesuiv returned %#lx\n", status );
}

static void WINAPI glUniformui64NV( GLint location, GLuint64EXT value )
{
    struct glUniformui64NV_params args = { .teb = NtCurrentTeb(), .location = location, .value = value };
    NTSTATUS status;
    TRACE( "location %d, value %s\n", location, wine_dbgstr_longlong(value) );
    if ((status = UNIX_CALL( glUniformui64NV, &args ))) WARN( "glUniformui64NV returned %#lx\n", status );
}

static void WINAPI glUniformui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
{
    struct glUniformui64vNV_params args = { .teb = NtCurrentTeb(), .location = location, .count = count, .value = value };
    NTSTATUS status;
    TRACE( "location %d, count %d, value %p\n", location, count, value );
    if ((status = UNIX_CALL( glUniformui64vNV, &args ))) WARN( "glUniformui64vNV returned %#lx\n", status );
}

static void WINAPI glUnlockArraysEXT(void)
{
    struct glUnlockArraysEXT_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glUnlockArraysEXT, &args ))) WARN( "glUnlockArraysEXT returned %#lx\n", status );
}

static void WINAPI glUnmapObjectBufferATI( GLuint buffer )
{
    struct glUnmapObjectBufferATI_params args = { .teb = NtCurrentTeb(), .buffer = buffer };
    NTSTATUS status;
    TRACE( "buffer %d\n", buffer );
    if ((status = UNIX_CALL( glUnmapObjectBufferATI, &args ))) WARN( "glUnmapObjectBufferATI returned %#lx\n", status );
}

static void WINAPI glUnmapTexture2DINTEL( GLuint texture, GLint level )
{
    struct glUnmapTexture2DINTEL_params args = { .teb = NtCurrentTeb(), .texture = texture, .level = level };
    NTSTATUS status;
    TRACE( "texture %d, level %d\n", texture, level );
    if ((status = UNIX_CALL( glUnmapTexture2DINTEL, &args ))) WARN( "glUnmapTexture2DINTEL returned %#lx\n", status );
}

static void WINAPI glUpdateObjectBufferATI( GLuint buffer, GLuint offset, GLsizei size, const void *pointer, GLenum preserve )
{
    struct glUpdateObjectBufferATI_params args = { .teb = NtCurrentTeb(), .buffer = buffer, .offset = offset, .size = size, .pointer = pointer, .preserve = preserve };
    NTSTATUS status;
    TRACE( "buffer %d, offset %d, size %d, pointer %p, preserve %d\n", buffer, offset, size, pointer, preserve );
    if ((status = UNIX_CALL( glUpdateObjectBufferATI, &args ))) WARN( "glUpdateObjectBufferATI returned %#lx\n", status );
}

static void WINAPI glUploadGpuMaskNVX( GLbitfield mask )
{
    struct glUploadGpuMaskNVX_params args = { .teb = NtCurrentTeb(), .mask = mask };
    NTSTATUS status;
    TRACE( "mask %d\n", mask );
    if ((status = UNIX_CALL( glUploadGpuMaskNVX, &args ))) WARN( "glUploadGpuMaskNVX returned %#lx\n", status );
}

static void WINAPI glUseProgram( GLuint program )
{
    struct glUseProgram_params args = { .teb = NtCurrentTeb(), .program = program };
    NTSTATUS status;
    TRACE( "program %d\n", program );
    if ((status = UNIX_CALL( glUseProgram, &args ))) WARN( "glUseProgram returned %#lx\n", status );
}

static void WINAPI glUseProgramObjectARB( GLhandleARB programObj )
{
    struct glUseProgramObjectARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj };
    NTSTATUS status;
    TRACE( "programObj %d\n", programObj );
    if ((status = UNIX_CALL( glUseProgramObjectARB, &args ))) WARN( "glUseProgramObjectARB returned %#lx\n", status );
}

static void WINAPI glUseProgramStages( GLuint pipeline, GLbitfield stages, GLuint program )
{
    struct glUseProgramStages_params args = { .teb = NtCurrentTeb(), .pipeline = pipeline, .stages = stages, .program = program };
    NTSTATUS status;
    TRACE( "pipeline %d, stages %d, program %d\n", pipeline, stages, program );
    if ((status = UNIX_CALL( glUseProgramStages, &args ))) WARN( "glUseProgramStages returned %#lx\n", status );
}

static void WINAPI glUseShaderProgramEXT( GLenum type, GLuint program )
{
    struct glUseShaderProgramEXT_params args = { .teb = NtCurrentTeb(), .type = type, .program = program };
    NTSTATUS status;
    TRACE( "type %d, program %d\n", type, program );
    if ((status = UNIX_CALL( glUseShaderProgramEXT, &args ))) WARN( "glUseShaderProgramEXT returned %#lx\n", status );
}

static void WINAPI glVDPAUFiniNV(void)
{
    struct glVDPAUFiniNV_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( glVDPAUFiniNV, &args ))) WARN( "glVDPAUFiniNV returned %#lx\n", status );
}

static void WINAPI glVDPAUGetSurfaceivNV( GLvdpauSurfaceNV surface, GLenum pname, GLsizei count, GLsizei *length, GLint *values )
{
    struct glVDPAUGetSurfaceivNV_params args = { .teb = NtCurrentTeb(), .surface = surface, .pname = pname, .count = count, .length = length, .values = values };
    NTSTATUS status;
    TRACE( "surface %Id, pname %d, count %d, length %p, values %p\n", surface, pname, count, length, values );
    if ((status = UNIX_CALL( glVDPAUGetSurfaceivNV, &args ))) WARN( "glVDPAUGetSurfaceivNV returned %#lx\n", status );
}

static void WINAPI glVDPAUInitNV( const void *vdpDevice, const void *getProcAddress )
{
    struct glVDPAUInitNV_params args = { .teb = NtCurrentTeb(), .vdpDevice = vdpDevice, .getProcAddress = getProcAddress };
    NTSTATUS status;
    TRACE( "vdpDevice %p, getProcAddress %p\n", vdpDevice, getProcAddress );
    if ((status = UNIX_CALL( glVDPAUInitNV, &args ))) WARN( "glVDPAUInitNV returned %#lx\n", status );
}

static GLboolean WINAPI glVDPAUIsSurfaceNV( GLvdpauSurfaceNV surface )
{
    struct glVDPAUIsSurfaceNV_params args = { .teb = NtCurrentTeb(), .surface = surface };
    NTSTATUS status;
    TRACE( "surface %Id\n", surface );
    if ((status = UNIX_CALL( glVDPAUIsSurfaceNV, &args ))) WARN( "glVDPAUIsSurfaceNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glVDPAUMapSurfacesNV( GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces )
{
    struct glVDPAUMapSurfacesNV_params args = { .teb = NtCurrentTeb(), .numSurfaces = numSurfaces, .surfaces = surfaces };
    NTSTATUS status;
    TRACE( "numSurfaces %d, surfaces %p\n", numSurfaces, surfaces );
    if ((status = UNIX_CALL( glVDPAUMapSurfacesNV, &args ))) WARN( "glVDPAUMapSurfacesNV returned %#lx\n", status );
}

static GLvdpauSurfaceNV WINAPI glVDPAURegisterOutputSurfaceNV( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames )
{
    struct glVDPAURegisterOutputSurfaceNV_params args = { .teb = NtCurrentTeb(), .vdpSurface = vdpSurface, .target = target, .numTextureNames = numTextureNames, .textureNames = textureNames };
    NTSTATUS status;
    TRACE( "vdpSurface %p, target %d, numTextureNames %d, textureNames %p\n", vdpSurface, target, numTextureNames, textureNames );
    if ((status = UNIX_CALL( glVDPAURegisterOutputSurfaceNV, &args ))) WARN( "glVDPAURegisterOutputSurfaceNV returned %#lx\n", status );
    return args.ret;
}

static GLvdpauSurfaceNV WINAPI glVDPAURegisterVideoSurfaceNV( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames )
{
    struct glVDPAURegisterVideoSurfaceNV_params args = { .teb = NtCurrentTeb(), .vdpSurface = vdpSurface, .target = target, .numTextureNames = numTextureNames, .textureNames = textureNames };
    NTSTATUS status;
    TRACE( "vdpSurface %p, target %d, numTextureNames %d, textureNames %p\n", vdpSurface, target, numTextureNames, textureNames );
    if ((status = UNIX_CALL( glVDPAURegisterVideoSurfaceNV, &args ))) WARN( "glVDPAURegisterVideoSurfaceNV returned %#lx\n", status );
    return args.ret;
}

static GLvdpauSurfaceNV WINAPI glVDPAURegisterVideoSurfaceWithPictureStructureNV( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames, GLboolean isFrameStructure )
{
    struct glVDPAURegisterVideoSurfaceWithPictureStructureNV_params args = { .teb = NtCurrentTeb(), .vdpSurface = vdpSurface, .target = target, .numTextureNames = numTextureNames, .textureNames = textureNames, .isFrameStructure = isFrameStructure };
    NTSTATUS status;
    TRACE( "vdpSurface %p, target %d, numTextureNames %d, textureNames %p, isFrameStructure %d\n", vdpSurface, target, numTextureNames, textureNames, isFrameStructure );
    if ((status = UNIX_CALL( glVDPAURegisterVideoSurfaceWithPictureStructureNV, &args ))) WARN( "glVDPAURegisterVideoSurfaceWithPictureStructureNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glVDPAUSurfaceAccessNV( GLvdpauSurfaceNV surface, GLenum access )
{
    struct glVDPAUSurfaceAccessNV_params args = { .teb = NtCurrentTeb(), .surface = surface, .access = access };
    NTSTATUS status;
    TRACE( "surface %Id, access %d\n", surface, access );
    if ((status = UNIX_CALL( glVDPAUSurfaceAccessNV, &args ))) WARN( "glVDPAUSurfaceAccessNV returned %#lx\n", status );
}

static void WINAPI glVDPAUUnmapSurfacesNV( GLsizei numSurface, const GLvdpauSurfaceNV *surfaces )
{
    struct glVDPAUUnmapSurfacesNV_params args = { .teb = NtCurrentTeb(), .numSurface = numSurface, .surfaces = surfaces };
    NTSTATUS status;
    TRACE( "numSurface %d, surfaces %p\n", numSurface, surfaces );
    if ((status = UNIX_CALL( glVDPAUUnmapSurfacesNV, &args ))) WARN( "glVDPAUUnmapSurfacesNV returned %#lx\n", status );
}

static void WINAPI glVDPAUUnregisterSurfaceNV( GLvdpauSurfaceNV surface )
{
    struct glVDPAUUnregisterSurfaceNV_params args = { .teb = NtCurrentTeb(), .surface = surface };
    NTSTATUS status;
    TRACE( "surface %Id\n", surface );
    if ((status = UNIX_CALL( glVDPAUUnregisterSurfaceNV, &args ))) WARN( "glVDPAUUnregisterSurfaceNV returned %#lx\n", status );
}

static void WINAPI glValidateProgram( GLuint program )
{
    struct glValidateProgram_params args = { .teb = NtCurrentTeb(), .program = program };
    NTSTATUS status;
    TRACE( "program %d\n", program );
    if ((status = UNIX_CALL( glValidateProgram, &args ))) WARN( "glValidateProgram returned %#lx\n", status );
}

static void WINAPI glValidateProgramARB( GLhandleARB programObj )
{
    struct glValidateProgramARB_params args = { .teb = NtCurrentTeb(), .programObj = programObj };
    NTSTATUS status;
    TRACE( "programObj %d\n", programObj );
    if ((status = UNIX_CALL( glValidateProgramARB, &args ))) WARN( "glValidateProgramARB returned %#lx\n", status );
}

static void WINAPI glValidateProgramPipeline( GLuint pipeline )
{
    struct glValidateProgramPipeline_params args = { .teb = NtCurrentTeb(), .pipeline = pipeline };
    NTSTATUS status;
    TRACE( "pipeline %d\n", pipeline );
    if ((status = UNIX_CALL( glValidateProgramPipeline, &args ))) WARN( "glValidateProgramPipeline returned %#lx\n", status );
}

static void WINAPI glVariantArrayObjectATI( GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset )
{
    struct glVariantArrayObjectATI_params args = { .teb = NtCurrentTeb(), .id = id, .type = type, .stride = stride, .buffer = buffer, .offset = offset };
    NTSTATUS status;
    TRACE( "id %d, type %d, stride %d, buffer %d, offset %d\n", id, type, stride, buffer, offset );
    if ((status = UNIX_CALL( glVariantArrayObjectATI, &args ))) WARN( "glVariantArrayObjectATI returned %#lx\n", status );
}

static void WINAPI glVariantPointerEXT( GLuint id, GLenum type, GLuint stride, const void *addr )
{
    struct glVariantPointerEXT_params args = { .teb = NtCurrentTeb(), .id = id, .type = type, .stride = stride, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, type %d, stride %d, addr %p\n", id, type, stride, addr );
    if ((status = UNIX_CALL( glVariantPointerEXT, &args ))) WARN( "glVariantPointerEXT returned %#lx\n", status );
}

static void WINAPI glVariantbvEXT( GLuint id, const GLbyte *addr )
{
    struct glVariantbvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, addr %p\n", id, addr );
    if ((status = UNIX_CALL( glVariantbvEXT, &args ))) WARN( "glVariantbvEXT returned %#lx\n", status );
}

static void WINAPI glVariantdvEXT( GLuint id, const GLdouble *addr )
{
    struct glVariantdvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, addr %p\n", id, addr );
    if ((status = UNIX_CALL( glVariantdvEXT, &args ))) WARN( "glVariantdvEXT returned %#lx\n", status );
}

static void WINAPI glVariantfvEXT( GLuint id, const GLfloat *addr )
{
    struct glVariantfvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, addr %p\n", id, addr );
    if ((status = UNIX_CALL( glVariantfvEXT, &args ))) WARN( "glVariantfvEXT returned %#lx\n", status );
}

static void WINAPI glVariantivEXT( GLuint id, const GLint *addr )
{
    struct glVariantivEXT_params args = { .teb = NtCurrentTeb(), .id = id, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, addr %p\n", id, addr );
    if ((status = UNIX_CALL( glVariantivEXT, &args ))) WARN( "glVariantivEXT returned %#lx\n", status );
}

static void WINAPI glVariantsvEXT( GLuint id, const GLshort *addr )
{
    struct glVariantsvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, addr %p\n", id, addr );
    if ((status = UNIX_CALL( glVariantsvEXT, &args ))) WARN( "glVariantsvEXT returned %#lx\n", status );
}

static void WINAPI glVariantubvEXT( GLuint id, const GLubyte *addr )
{
    struct glVariantubvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, addr %p\n", id, addr );
    if ((status = UNIX_CALL( glVariantubvEXT, &args ))) WARN( "glVariantubvEXT returned %#lx\n", status );
}

static void WINAPI glVariantuivEXT( GLuint id, const GLuint *addr )
{
    struct glVariantuivEXT_params args = { .teb = NtCurrentTeb(), .id = id, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, addr %p\n", id, addr );
    if ((status = UNIX_CALL( glVariantuivEXT, &args ))) WARN( "glVariantuivEXT returned %#lx\n", status );
}

static void WINAPI glVariantusvEXT( GLuint id, const GLushort *addr )
{
    struct glVariantusvEXT_params args = { .teb = NtCurrentTeb(), .id = id, .addr = addr };
    NTSTATUS status;
    TRACE( "id %d, addr %p\n", id, addr );
    if ((status = UNIX_CALL( glVariantusvEXT, &args ))) WARN( "glVariantusvEXT returned %#lx\n", status );
}

static void WINAPI glVertex2bOES( GLbyte x, GLbyte y )
{
    struct glVertex2bOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glVertex2bOES, &args ))) WARN( "glVertex2bOES returned %#lx\n", status );
}

static void WINAPI glVertex2bvOES( const GLbyte *coords )
{
    struct glVertex2bvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glVertex2bvOES, &args ))) WARN( "glVertex2bvOES returned %#lx\n", status );
}

static void WINAPI glVertex2hNV( GLhalfNV x, GLhalfNV y )
{
    struct glVertex2hNV_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glVertex2hNV, &args ))) WARN( "glVertex2hNV returned %#lx\n", status );
}

static void WINAPI glVertex2hvNV( const GLhalfNV *v )
{
    struct glVertex2hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex2hvNV, &args ))) WARN( "glVertex2hvNV returned %#lx\n", status );
}

static void WINAPI glVertex2xOES( GLfixed x )
{
    struct glVertex2xOES_params args = { .teb = NtCurrentTeb(), .x = x };
    NTSTATUS status;
    TRACE( "x %d\n", x );
    if ((status = UNIX_CALL( glVertex2xOES, &args ))) WARN( "glVertex2xOES returned %#lx\n", status );
}

static void WINAPI glVertex2xvOES( const GLfixed *coords )
{
    struct glVertex2xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glVertex2xvOES, &args ))) WARN( "glVertex2xvOES returned %#lx\n", status );
}

static void WINAPI glVertex3bOES( GLbyte x, GLbyte y, GLbyte z )
{
    struct glVertex3bOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glVertex3bOES, &args ))) WARN( "glVertex3bOES returned %#lx\n", status );
}

static void WINAPI glVertex3bvOES( const GLbyte *coords )
{
    struct glVertex3bvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glVertex3bvOES, &args ))) WARN( "glVertex3bvOES returned %#lx\n", status );
}

static void WINAPI glVertex3hNV( GLhalfNV x, GLhalfNV y, GLhalfNV z )
{
    struct glVertex3hNV_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glVertex3hNV, &args ))) WARN( "glVertex3hNV returned %#lx\n", status );
}

static void WINAPI glVertex3hvNV( const GLhalfNV *v )
{
    struct glVertex3hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex3hvNV, &args ))) WARN( "glVertex3hvNV returned %#lx\n", status );
}

static void WINAPI glVertex3xOES( GLfixed x, GLfixed y )
{
    struct glVertex3xOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glVertex3xOES, &args ))) WARN( "glVertex3xOES returned %#lx\n", status );
}

static void WINAPI glVertex3xvOES( const GLfixed *coords )
{
    struct glVertex3xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glVertex3xvOES, &args ))) WARN( "glVertex3xvOES returned %#lx\n", status );
}

static void WINAPI glVertex4bOES( GLbyte x, GLbyte y, GLbyte z, GLbyte w )
{
    struct glVertex4bOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glVertex4bOES, &args ))) WARN( "glVertex4bOES returned %#lx\n", status );
}

static void WINAPI glVertex4bvOES( const GLbyte *coords )
{
    struct glVertex4bvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glVertex4bvOES, &args ))) WARN( "glVertex4bvOES returned %#lx\n", status );
}

static void WINAPI glVertex4hNV( GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w )
{
    struct glVertex4hNV_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glVertex4hNV, &args ))) WARN( "glVertex4hNV returned %#lx\n", status );
}

static void WINAPI glVertex4hvNV( const GLhalfNV *v )
{
    struct glVertex4hvNV_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glVertex4hvNV, &args ))) WARN( "glVertex4hvNV returned %#lx\n", status );
}

static void WINAPI glVertex4xOES( GLfixed x, GLfixed y, GLfixed z )
{
    struct glVertex4xOES_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glVertex4xOES, &args ))) WARN( "glVertex4xOES returned %#lx\n", status );
}

static void WINAPI glVertex4xvOES( const GLfixed *coords )
{
    struct glVertex4xvOES_params args = { .teb = NtCurrentTeb(), .coords = coords };
    NTSTATUS status;
    TRACE( "coords %p\n", coords );
    if ((status = UNIX_CALL( glVertex4xvOES, &args ))) WARN( "glVertex4xvOES returned %#lx\n", status );
}

static void WINAPI glVertexArrayAttribBinding( GLuint vaobj, GLuint attribindex, GLuint bindingindex )
{
    struct glVertexArrayAttribBinding_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .attribindex = attribindex, .bindingindex = bindingindex };
    NTSTATUS status;
    TRACE( "vaobj %d, attribindex %d, bindingindex %d\n", vaobj, attribindex, bindingindex );
    if ((status = UNIX_CALL( glVertexArrayAttribBinding, &args ))) WARN( "glVertexArrayAttribBinding returned %#lx\n", status );
}

static void WINAPI glVertexArrayAttribFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset )
{
    struct glVertexArrayAttribFormat_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .attribindex = attribindex, .size = size, .type = type, .normalized = normalized, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "vaobj %d, attribindex %d, size %d, type %d, normalized %d, relativeoffset %d\n", vaobj, attribindex, size, type, normalized, relativeoffset );
    if ((status = UNIX_CALL( glVertexArrayAttribFormat, &args ))) WARN( "glVertexArrayAttribFormat returned %#lx\n", status );
}

static void WINAPI glVertexArrayAttribIFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
{
    struct glVertexArrayAttribIFormat_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .attribindex = attribindex, .size = size, .type = type, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "vaobj %d, attribindex %d, size %d, type %d, relativeoffset %d\n", vaobj, attribindex, size, type, relativeoffset );
    if ((status = UNIX_CALL( glVertexArrayAttribIFormat, &args ))) WARN( "glVertexArrayAttribIFormat returned %#lx\n", status );
}

static void WINAPI glVertexArrayAttribLFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
{
    struct glVertexArrayAttribLFormat_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .attribindex = attribindex, .size = size, .type = type, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "vaobj %d, attribindex %d, size %d, type %d, relativeoffset %d\n", vaobj, attribindex, size, type, relativeoffset );
    if ((status = UNIX_CALL( glVertexArrayAttribLFormat, &args ))) WARN( "glVertexArrayAttribLFormat returned %#lx\n", status );
}

static void WINAPI glVertexArrayBindVertexBufferEXT( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride )
{
    struct glVertexArrayBindVertexBufferEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .bindingindex = bindingindex, .buffer = buffer, .offset = offset, .stride = stride };
    NTSTATUS status;
    TRACE( "vaobj %d, bindingindex %d, buffer %d, offset %Id, stride %d\n", vaobj, bindingindex, buffer, offset, stride );
    if ((status = UNIX_CALL( glVertexArrayBindVertexBufferEXT, &args ))) WARN( "glVertexArrayBindVertexBufferEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayBindingDivisor( GLuint vaobj, GLuint bindingindex, GLuint divisor )
{
    struct glVertexArrayBindingDivisor_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .bindingindex = bindingindex, .divisor = divisor };
    NTSTATUS status;
    TRACE( "vaobj %d, bindingindex %d, divisor %d\n", vaobj, bindingindex, divisor );
    if ((status = UNIX_CALL( glVertexArrayBindingDivisor, &args ))) WARN( "glVertexArrayBindingDivisor returned %#lx\n", status );
}

static void WINAPI glVertexArrayColorOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayColorOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .size = size, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, size %d, type %d, stride %d, offset %Id\n", vaobj, buffer, size, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayColorOffsetEXT, &args ))) WARN( "glVertexArrayColorOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayEdgeFlagOffsetEXT( GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayEdgeFlagOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, stride %d, offset %Id\n", vaobj, buffer, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayEdgeFlagOffsetEXT, &args ))) WARN( "glVertexArrayEdgeFlagOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayElementBuffer( GLuint vaobj, GLuint buffer )
{
    struct glVertexArrayElementBuffer_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d\n", vaobj, buffer );
    if ((status = UNIX_CALL( glVertexArrayElementBuffer, &args ))) WARN( "glVertexArrayElementBuffer returned %#lx\n", status );
}

static void WINAPI glVertexArrayFogCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayFogCoordOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, type %d, stride %d, offset %Id\n", vaobj, buffer, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayFogCoordOffsetEXT, &args ))) WARN( "glVertexArrayFogCoordOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayIndexOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayIndexOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, type %d, stride %d, offset %Id\n", vaobj, buffer, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayIndexOffsetEXT, &args ))) WARN( "glVertexArrayIndexOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayMultiTexCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayMultiTexCoordOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .texunit = texunit, .size = size, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, texunit %d, size %d, type %d, stride %d, offset %Id\n", vaobj, buffer, texunit, size, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayMultiTexCoordOffsetEXT, &args ))) WARN( "glVertexArrayMultiTexCoordOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayNormalOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayNormalOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, type %d, stride %d, offset %Id\n", vaobj, buffer, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayNormalOffsetEXT, &args ))) WARN( "glVertexArrayNormalOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayParameteriAPPLE( GLenum pname, GLint param )
{
    struct glVertexArrayParameteriAPPLE_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glVertexArrayParameteriAPPLE, &args ))) WARN( "glVertexArrayParameteriAPPLE returned %#lx\n", status );
}

static void WINAPI glVertexArrayRangeAPPLE( GLsizei length, void *pointer )
{
    struct glVertexArrayRangeAPPLE_params args = { .teb = NtCurrentTeb(), .length = length, .pointer = pointer };
    NTSTATUS status;
    TRACE( "length %d, pointer %p\n", length, pointer );
    if ((status = UNIX_CALL( glVertexArrayRangeAPPLE, &args ))) WARN( "glVertexArrayRangeAPPLE returned %#lx\n", status );
}

static void WINAPI glVertexArrayRangeNV( GLsizei length, const void *pointer )
{
    struct glVertexArrayRangeNV_params args = { .teb = NtCurrentTeb(), .length = length, .pointer = pointer };
    NTSTATUS status;
    TRACE( "length %d, pointer %p\n", length, pointer );
    if ((status = UNIX_CALL( glVertexArrayRangeNV, &args ))) WARN( "glVertexArrayRangeNV returned %#lx\n", status );
}

static void WINAPI glVertexArraySecondaryColorOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArraySecondaryColorOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .size = size, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, size %d, type %d, stride %d, offset %Id\n", vaobj, buffer, size, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArraySecondaryColorOffsetEXT, &args ))) WARN( "glVertexArraySecondaryColorOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayTexCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayTexCoordOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .size = size, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, size %d, type %d, stride %d, offset %Id\n", vaobj, buffer, size, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayTexCoordOffsetEXT, &args ))) WARN( "glVertexArrayTexCoordOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexAttribBindingEXT( GLuint vaobj, GLuint attribindex, GLuint bindingindex )
{
    struct glVertexArrayVertexAttribBindingEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .attribindex = attribindex, .bindingindex = bindingindex };
    NTSTATUS status;
    TRACE( "vaobj %d, attribindex %d, bindingindex %d\n", vaobj, attribindex, bindingindex );
    if ((status = UNIX_CALL( glVertexArrayVertexAttribBindingEXT, &args ))) WARN( "glVertexArrayVertexAttribBindingEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexAttribDivisorEXT( GLuint vaobj, GLuint index, GLuint divisor )
{
    struct glVertexArrayVertexAttribDivisorEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .index = index, .divisor = divisor };
    NTSTATUS status;
    TRACE( "vaobj %d, index %d, divisor %d\n", vaobj, index, divisor );
    if ((status = UNIX_CALL( glVertexArrayVertexAttribDivisorEXT, &args ))) WARN( "glVertexArrayVertexAttribDivisorEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexAttribFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset )
{
    struct glVertexArrayVertexAttribFormatEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .attribindex = attribindex, .size = size, .type = type, .normalized = normalized, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "vaobj %d, attribindex %d, size %d, type %d, normalized %d, relativeoffset %d\n", vaobj, attribindex, size, type, normalized, relativeoffset );
    if ((status = UNIX_CALL( glVertexArrayVertexAttribFormatEXT, &args ))) WARN( "glVertexArrayVertexAttribFormatEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexAttribIFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
{
    struct glVertexArrayVertexAttribIFormatEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .attribindex = attribindex, .size = size, .type = type, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "vaobj %d, attribindex %d, size %d, type %d, relativeoffset %d\n", vaobj, attribindex, size, type, relativeoffset );
    if ((status = UNIX_CALL( glVertexArrayVertexAttribIFormatEXT, &args ))) WARN( "glVertexArrayVertexAttribIFormatEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexAttribIOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayVertexAttribIOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .index = index, .size = size, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, index %d, size %d, type %d, stride %d, offset %Id\n", vaobj, buffer, index, size, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayVertexAttribIOffsetEXT, &args ))) WARN( "glVertexArrayVertexAttribIOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexAttribLFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
{
    struct glVertexArrayVertexAttribLFormatEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .attribindex = attribindex, .size = size, .type = type, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "vaobj %d, attribindex %d, size %d, type %d, relativeoffset %d\n", vaobj, attribindex, size, type, relativeoffset );
    if ((status = UNIX_CALL( glVertexArrayVertexAttribLFormatEXT, &args ))) WARN( "glVertexArrayVertexAttribLFormatEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexAttribLOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayVertexAttribLOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .index = index, .size = size, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, index %d, size %d, type %d, stride %d, offset %Id\n", vaobj, buffer, index, size, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayVertexAttribLOffsetEXT, &args ))) WARN( "glVertexArrayVertexAttribLOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexAttribOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayVertexAttribOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .index = index, .size = size, .type = type, .normalized = normalized, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, index %d, size %d, type %d, normalized %d, stride %d, offset %Id\n", vaobj, buffer, index, size, type, normalized, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayVertexAttribOffsetEXT, &args ))) WARN( "glVertexArrayVertexAttribOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexBindingDivisorEXT( GLuint vaobj, GLuint bindingindex, GLuint divisor )
{
    struct glVertexArrayVertexBindingDivisorEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .bindingindex = bindingindex, .divisor = divisor };
    NTSTATUS status;
    TRACE( "vaobj %d, bindingindex %d, divisor %d\n", vaobj, bindingindex, divisor );
    if ((status = UNIX_CALL( glVertexArrayVertexBindingDivisorEXT, &args ))) WARN( "glVertexArrayVertexBindingDivisorEXT returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexBuffer( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride )
{
    struct glVertexArrayVertexBuffer_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .bindingindex = bindingindex, .buffer = buffer, .offset = offset, .stride = stride };
    NTSTATUS status;
    TRACE( "vaobj %d, bindingindex %d, buffer %d, offset %Id, stride %d\n", vaobj, bindingindex, buffer, offset, stride );
    if ((status = UNIX_CALL( glVertexArrayVertexBuffer, &args ))) WARN( "glVertexArrayVertexBuffer returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexBuffers( GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides )
{
    struct glVertexArrayVertexBuffers_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .first = first, .count = count, .buffers = buffers, .offsets = offsets, .strides = strides };
    NTSTATUS status;
    TRACE( "vaobj %d, first %d, count %d, buffers %p, offsets %p, strides %p\n", vaobj, first, count, buffers, offsets, strides );
    if ((status = UNIX_CALL( glVertexArrayVertexBuffers, &args ))) WARN( "glVertexArrayVertexBuffers returned %#lx\n", status );
}

static void WINAPI glVertexArrayVertexOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset )
{
    struct glVertexArrayVertexOffsetEXT_params args = { .teb = NtCurrentTeb(), .vaobj = vaobj, .buffer = buffer, .size = size, .type = type, .stride = stride, .offset = offset };
    NTSTATUS status;
    TRACE( "vaobj %d, buffer %d, size %d, type %d, stride %d, offset %Id\n", vaobj, buffer, size, type, stride, offset );
    if ((status = UNIX_CALL( glVertexArrayVertexOffsetEXT, &args ))) WARN( "glVertexArrayVertexOffsetEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1d( GLuint index, GLdouble x )
{
    struct glVertexAttrib1d_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %f\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1d, &args ))) WARN( "glVertexAttrib1d returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1dARB( GLuint index, GLdouble x )
{
    struct glVertexAttrib1dARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %f\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1dARB, &args ))) WARN( "glVertexAttrib1dARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1dNV( GLuint index, GLdouble x )
{
    struct glVertexAttrib1dNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %f\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1dNV, &args ))) WARN( "glVertexAttrib1dNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1dv( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib1dv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1dv, &args ))) WARN( "glVertexAttrib1dv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1dvARB( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib1dvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1dvARB, &args ))) WARN( "glVertexAttrib1dvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1dvNV( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib1dvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1dvNV, &args ))) WARN( "glVertexAttrib1dvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1f( GLuint index, GLfloat x )
{
    struct glVertexAttrib1f_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %f\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1f, &args ))) WARN( "glVertexAttrib1f returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1fARB( GLuint index, GLfloat x )
{
    struct glVertexAttrib1fARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %f\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1fARB, &args ))) WARN( "glVertexAttrib1fARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1fNV( GLuint index, GLfloat x )
{
    struct glVertexAttrib1fNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %f\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1fNV, &args ))) WARN( "glVertexAttrib1fNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1fv( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib1fv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1fv, &args ))) WARN( "glVertexAttrib1fv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1fvARB( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib1fvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1fvARB, &args ))) WARN( "glVertexAttrib1fvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1fvNV( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib1fvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1fvNV, &args ))) WARN( "glVertexAttrib1fvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1hNV( GLuint index, GLhalfNV x )
{
    struct glVertexAttrib1hNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %d\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1hNV, &args ))) WARN( "glVertexAttrib1hNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1hvNV( GLuint index, const GLhalfNV *v )
{
    struct glVertexAttrib1hvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1hvNV, &args ))) WARN( "glVertexAttrib1hvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1s( GLuint index, GLshort x )
{
    struct glVertexAttrib1s_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %d\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1s, &args ))) WARN( "glVertexAttrib1s returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1sARB( GLuint index, GLshort x )
{
    struct glVertexAttrib1sARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %d\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1sARB, &args ))) WARN( "glVertexAttrib1sARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1sNV( GLuint index, GLshort x )
{
    struct glVertexAttrib1sNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %d\n", index, x );
    if ((status = UNIX_CALL( glVertexAttrib1sNV, &args ))) WARN( "glVertexAttrib1sNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1sv( GLuint index, const GLshort *v )
{
    struct glVertexAttrib1sv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1sv, &args ))) WARN( "glVertexAttrib1sv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1svARB( GLuint index, const GLshort *v )
{
    struct glVertexAttrib1svARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1svARB, &args ))) WARN( "glVertexAttrib1svARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib1svNV( GLuint index, const GLshort *v )
{
    struct glVertexAttrib1svNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib1svNV, &args ))) WARN( "glVertexAttrib1svNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2d( GLuint index, GLdouble x, GLdouble y )
{
    struct glVertexAttrib2d_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2d, &args ))) WARN( "glVertexAttrib2d returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2dARB( GLuint index, GLdouble x, GLdouble y )
{
    struct glVertexAttrib2dARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2dARB, &args ))) WARN( "glVertexAttrib2dARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2dNV( GLuint index, GLdouble x, GLdouble y )
{
    struct glVertexAttrib2dNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2dNV, &args ))) WARN( "glVertexAttrib2dNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2dv( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib2dv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2dv, &args ))) WARN( "glVertexAttrib2dv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2dvARB( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib2dvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2dvARB, &args ))) WARN( "glVertexAttrib2dvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2dvNV( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib2dvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2dvNV, &args ))) WARN( "glVertexAttrib2dvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2f( GLuint index, GLfloat x, GLfloat y )
{
    struct glVertexAttrib2f_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2f, &args ))) WARN( "glVertexAttrib2f returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y )
{
    struct glVertexAttrib2fARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2fARB, &args ))) WARN( "glVertexAttrib2fARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y )
{
    struct glVertexAttrib2fNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2fNV, &args ))) WARN( "glVertexAttrib2fNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2fv( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib2fv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2fv, &args ))) WARN( "glVertexAttrib2fv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2fvARB( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib2fvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2fvARB, &args ))) WARN( "glVertexAttrib2fvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2fvNV( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib2fvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2fvNV, &args ))) WARN( "glVertexAttrib2fvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2hNV( GLuint index, GLhalfNV x, GLhalfNV y )
{
    struct glVertexAttrib2hNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2hNV, &args ))) WARN( "glVertexAttrib2hNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2hvNV( GLuint index, const GLhalfNV *v )
{
    struct glVertexAttrib2hvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2hvNV, &args ))) WARN( "glVertexAttrib2hvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2s( GLuint index, GLshort x, GLshort y )
{
    struct glVertexAttrib2s_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2s, &args ))) WARN( "glVertexAttrib2s returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2sARB( GLuint index, GLshort x, GLshort y )
{
    struct glVertexAttrib2sARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2sARB, &args ))) WARN( "glVertexAttrib2sARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2sNV( GLuint index, GLshort x, GLshort y )
{
    struct glVertexAttrib2sNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttrib2sNV, &args ))) WARN( "glVertexAttrib2sNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2sv( GLuint index, const GLshort *v )
{
    struct glVertexAttrib2sv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2sv, &args ))) WARN( "glVertexAttrib2sv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2svARB( GLuint index, const GLshort *v )
{
    struct glVertexAttrib2svARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2svARB, &args ))) WARN( "glVertexAttrib2svARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib2svNV( GLuint index, const GLshort *v )
{
    struct glVertexAttrib2svNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib2svNV, &args ))) WARN( "glVertexAttrib2svNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3d( GLuint index, GLdouble x, GLdouble y, GLdouble z )
{
    struct glVertexAttrib3d_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3d, &args ))) WARN( "glVertexAttrib3d returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z )
{
    struct glVertexAttrib3dARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3dARB, &args ))) WARN( "glVertexAttrib3dARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z )
{
    struct glVertexAttrib3dNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3dNV, &args ))) WARN( "glVertexAttrib3dNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3dv( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib3dv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3dv, &args ))) WARN( "glVertexAttrib3dv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3dvARB( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib3dvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3dvARB, &args ))) WARN( "glVertexAttrib3dvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3dvNV( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib3dvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3dvNV, &args ))) WARN( "glVertexAttrib3dvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3f( GLuint index, GLfloat x, GLfloat y, GLfloat z )
{
    struct glVertexAttrib3f_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3f, &args ))) WARN( "glVertexAttrib3f returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z )
{
    struct glVertexAttrib3fARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3fARB, &args ))) WARN( "glVertexAttrib3fARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z )
{
    struct glVertexAttrib3fNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3fNV, &args ))) WARN( "glVertexAttrib3fNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3fv( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib3fv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3fv, &args ))) WARN( "glVertexAttrib3fv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3fvARB( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib3fvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3fvARB, &args ))) WARN( "glVertexAttrib3fvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3fvNV( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib3fvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3fvNV, &args ))) WARN( "glVertexAttrib3fvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3hNV( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z )
{
    struct glVertexAttrib3hNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3hNV, &args ))) WARN( "glVertexAttrib3hNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3hvNV( GLuint index, const GLhalfNV *v )
{
    struct glVertexAttrib3hvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3hvNV, &args ))) WARN( "glVertexAttrib3hvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3s( GLuint index, GLshort x, GLshort y, GLshort z )
{
    struct glVertexAttrib3s_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3s, &args ))) WARN( "glVertexAttrib3s returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3sARB( GLuint index, GLshort x, GLshort y, GLshort z )
{
    struct glVertexAttrib3sARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3sARB, &args ))) WARN( "glVertexAttrib3sARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3sNV( GLuint index, GLshort x, GLshort y, GLshort z )
{
    struct glVertexAttrib3sNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttrib3sNV, &args ))) WARN( "glVertexAttrib3sNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3sv( GLuint index, const GLshort *v )
{
    struct glVertexAttrib3sv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3sv, &args ))) WARN( "glVertexAttrib3sv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3svARB( GLuint index, const GLshort *v )
{
    struct glVertexAttrib3svARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3svARB, &args ))) WARN( "glVertexAttrib3svARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib3svNV( GLuint index, const GLshort *v )
{
    struct glVertexAttrib3svNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib3svNV, &args ))) WARN( "glVertexAttrib3svNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4Nbv( GLuint index, const GLbyte *v )
{
    struct glVertexAttrib4Nbv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4Nbv, &args ))) WARN( "glVertexAttrib4Nbv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4NbvARB( GLuint index, const GLbyte *v )
{
    struct glVertexAttrib4NbvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4NbvARB, &args ))) WARN( "glVertexAttrib4NbvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4Niv( GLuint index, const GLint *v )
{
    struct glVertexAttrib4Niv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4Niv, &args ))) WARN( "glVertexAttrib4Niv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4NivARB( GLuint index, const GLint *v )
{
    struct glVertexAttrib4NivARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4NivARB, &args ))) WARN( "glVertexAttrib4NivARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4Nsv( GLuint index, const GLshort *v )
{
    struct glVertexAttrib4Nsv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4Nsv, &args ))) WARN( "glVertexAttrib4Nsv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4NsvARB( GLuint index, const GLshort *v )
{
    struct glVertexAttrib4NsvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4NsvARB, &args ))) WARN( "glVertexAttrib4NsvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4Nub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
{
    struct glVertexAttrib4Nub_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4Nub, &args ))) WARN( "glVertexAttrib4Nub returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4NubARB( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
{
    struct glVertexAttrib4NubARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4NubARB, &args ))) WARN( "glVertexAttrib4NubARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4Nubv( GLuint index, const GLubyte *v )
{
    struct glVertexAttrib4Nubv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4Nubv, &args ))) WARN( "glVertexAttrib4Nubv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4NubvARB( GLuint index, const GLubyte *v )
{
    struct glVertexAttrib4NubvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4NubvARB, &args ))) WARN( "glVertexAttrib4NubvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4Nuiv( GLuint index, const GLuint *v )
{
    struct glVertexAttrib4Nuiv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4Nuiv, &args ))) WARN( "glVertexAttrib4Nuiv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4NuivARB( GLuint index, const GLuint *v )
{
    struct glVertexAttrib4NuivARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4NuivARB, &args ))) WARN( "glVertexAttrib4NuivARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4Nusv( GLuint index, const GLushort *v )
{
    struct glVertexAttrib4Nusv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4Nusv, &args ))) WARN( "glVertexAttrib4Nusv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4NusvARB( GLuint index, const GLushort *v )
{
    struct glVertexAttrib4NusvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4NusvARB, &args ))) WARN( "glVertexAttrib4NusvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4bv( GLuint index, const GLbyte *v )
{
    struct glVertexAttrib4bv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4bv, &args ))) WARN( "glVertexAttrib4bv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4bvARB( GLuint index, const GLbyte *v )
{
    struct glVertexAttrib4bvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4bvARB, &args ))) WARN( "glVertexAttrib4bvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glVertexAttrib4d_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f, w %f\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4d, &args ))) WARN( "glVertexAttrib4d returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glVertexAttrib4dARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f, w %f\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4dARB, &args ))) WARN( "glVertexAttrib4dARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glVertexAttrib4dNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f, w %f\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4dNV, &args ))) WARN( "glVertexAttrib4dNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4dv( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib4dv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4dv, &args ))) WARN( "glVertexAttrib4dv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4dvARB( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib4dvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4dvARB, &args ))) WARN( "glVertexAttrib4dvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4dvNV( GLuint index, const GLdouble *v )
{
    struct glVertexAttrib4dvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4dvNV, &args ))) WARN( "glVertexAttrib4dvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glVertexAttrib4f_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f, w %f\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4f, &args ))) WARN( "glVertexAttrib4f returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glVertexAttrib4fARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f, w %f\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4fARB, &args ))) WARN( "glVertexAttrib4fARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glVertexAttrib4fNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f, w %f\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4fNV, &args ))) WARN( "glVertexAttrib4fNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4fv( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib4fv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4fv, &args ))) WARN( "glVertexAttrib4fv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4fvARB( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib4fvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4fvARB, &args ))) WARN( "glVertexAttrib4fvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4fvNV( GLuint index, const GLfloat *v )
{
    struct glVertexAttrib4fvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4fvNV, &args ))) WARN( "glVertexAttrib4fvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4hNV( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w )
{
    struct glVertexAttrib4hNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4hNV, &args ))) WARN( "glVertexAttrib4hNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4hvNV( GLuint index, const GLhalfNV *v )
{
    struct glVertexAttrib4hvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4hvNV, &args ))) WARN( "glVertexAttrib4hvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4iv( GLuint index, const GLint *v )
{
    struct glVertexAttrib4iv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4iv, &args ))) WARN( "glVertexAttrib4iv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4ivARB( GLuint index, const GLint *v )
{
    struct glVertexAttrib4ivARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4ivARB, &args ))) WARN( "glVertexAttrib4ivARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4s( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w )
{
    struct glVertexAttrib4s_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4s, &args ))) WARN( "glVertexAttrib4s returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4sARB( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w )
{
    struct glVertexAttrib4sARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4sARB, &args ))) WARN( "glVertexAttrib4sARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4sNV( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w )
{
    struct glVertexAttrib4sNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4sNV, &args ))) WARN( "glVertexAttrib4sNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4sv( GLuint index, const GLshort *v )
{
    struct glVertexAttrib4sv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4sv, &args ))) WARN( "glVertexAttrib4sv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4svARB( GLuint index, const GLshort *v )
{
    struct glVertexAttrib4svARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4svARB, &args ))) WARN( "glVertexAttrib4svARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4svNV( GLuint index, const GLshort *v )
{
    struct glVertexAttrib4svNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4svNV, &args ))) WARN( "glVertexAttrib4svNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4ubNV( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
{
    struct glVertexAttrib4ubNV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttrib4ubNV, &args ))) WARN( "glVertexAttrib4ubNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4ubv( GLuint index, const GLubyte *v )
{
    struct glVertexAttrib4ubv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4ubv, &args ))) WARN( "glVertexAttrib4ubv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4ubvARB( GLuint index, const GLubyte *v )
{
    struct glVertexAttrib4ubvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4ubvARB, &args ))) WARN( "glVertexAttrib4ubvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4ubvNV( GLuint index, const GLubyte *v )
{
    struct glVertexAttrib4ubvNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4ubvNV, &args ))) WARN( "glVertexAttrib4ubvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4uiv( GLuint index, const GLuint *v )
{
    struct glVertexAttrib4uiv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4uiv, &args ))) WARN( "glVertexAttrib4uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4uivARB( GLuint index, const GLuint *v )
{
    struct glVertexAttrib4uivARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4uivARB, &args ))) WARN( "glVertexAttrib4uivARB returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4usv( GLuint index, const GLushort *v )
{
    struct glVertexAttrib4usv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4usv, &args ))) WARN( "glVertexAttrib4usv returned %#lx\n", status );
}

static void WINAPI glVertexAttrib4usvARB( GLuint index, const GLushort *v )
{
    struct glVertexAttrib4usvARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttrib4usvARB, &args ))) WARN( "glVertexAttrib4usvARB returned %#lx\n", status );
}

static void WINAPI glVertexAttribArrayObjectATI( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset )
{
    struct glVertexAttribArrayObjectATI_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .normalized = normalized, .stride = stride, .buffer = buffer, .offset = offset };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, normalized %d, stride %d, buffer %d, offset %d\n", index, size, type, normalized, stride, buffer, offset );
    if ((status = UNIX_CALL( glVertexAttribArrayObjectATI, &args ))) WARN( "glVertexAttribArrayObjectATI returned %#lx\n", status );
}

static void WINAPI glVertexAttribBinding( GLuint attribindex, GLuint bindingindex )
{
    struct glVertexAttribBinding_params args = { .teb = NtCurrentTeb(), .attribindex = attribindex, .bindingindex = bindingindex };
    NTSTATUS status;
    TRACE( "attribindex %d, bindingindex %d\n", attribindex, bindingindex );
    if ((status = UNIX_CALL( glVertexAttribBinding, &args ))) WARN( "glVertexAttribBinding returned %#lx\n", status );
}

static void WINAPI glVertexAttribDivisor( GLuint index, GLuint divisor )
{
    struct glVertexAttribDivisor_params args = { .teb = NtCurrentTeb(), .index = index, .divisor = divisor };
    NTSTATUS status;
    TRACE( "index %d, divisor %d\n", index, divisor );
    if ((status = UNIX_CALL( glVertexAttribDivisor, &args ))) WARN( "glVertexAttribDivisor returned %#lx\n", status );
}

static void WINAPI glVertexAttribDivisorARB( GLuint index, GLuint divisor )
{
    struct glVertexAttribDivisorARB_params args = { .teb = NtCurrentTeb(), .index = index, .divisor = divisor };
    NTSTATUS status;
    TRACE( "index %d, divisor %d\n", index, divisor );
    if ((status = UNIX_CALL( glVertexAttribDivisorARB, &args ))) WARN( "glVertexAttribDivisorARB returned %#lx\n", status );
}

static void WINAPI glVertexAttribFormat( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset )
{
    struct glVertexAttribFormat_params args = { .teb = NtCurrentTeb(), .attribindex = attribindex, .size = size, .type = type, .normalized = normalized, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "attribindex %d, size %d, type %d, normalized %d, relativeoffset %d\n", attribindex, size, type, normalized, relativeoffset );
    if ((status = UNIX_CALL( glVertexAttribFormat, &args ))) WARN( "glVertexAttribFormat returned %#lx\n", status );
}

static void WINAPI glVertexAttribFormatNV( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride )
{
    struct glVertexAttribFormatNV_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .normalized = normalized, .stride = stride };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, normalized %d, stride %d\n", index, size, type, normalized, stride );
    if ((status = UNIX_CALL( glVertexAttribFormatNV, &args ))) WARN( "glVertexAttribFormatNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribI1i( GLuint index, GLint x )
{
    struct glVertexAttribI1i_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %d\n", index, x );
    if ((status = UNIX_CALL( glVertexAttribI1i, &args ))) WARN( "glVertexAttribI1i returned %#lx\n", status );
}

static void WINAPI glVertexAttribI1iEXT( GLuint index, GLint x )
{
    struct glVertexAttribI1iEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %d\n", index, x );
    if ((status = UNIX_CALL( glVertexAttribI1iEXT, &args ))) WARN( "glVertexAttribI1iEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI1iv( GLuint index, const GLint *v )
{
    struct glVertexAttribI1iv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI1iv, &args ))) WARN( "glVertexAttribI1iv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI1ivEXT( GLuint index, const GLint *v )
{
    struct glVertexAttribI1ivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI1ivEXT, &args ))) WARN( "glVertexAttribI1ivEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI1ui( GLuint index, GLuint x )
{
    struct glVertexAttribI1ui_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %d\n", index, x );
    if ((status = UNIX_CALL( glVertexAttribI1ui, &args ))) WARN( "glVertexAttribI1ui returned %#lx\n", status );
}

static void WINAPI glVertexAttribI1uiEXT( GLuint index, GLuint x )
{
    struct glVertexAttribI1uiEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %d\n", index, x );
    if ((status = UNIX_CALL( glVertexAttribI1uiEXT, &args ))) WARN( "glVertexAttribI1uiEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI1uiv( GLuint index, const GLuint *v )
{
    struct glVertexAttribI1uiv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI1uiv, &args ))) WARN( "glVertexAttribI1uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI1uivEXT( GLuint index, const GLuint *v )
{
    struct glVertexAttribI1uivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI1uivEXT, &args ))) WARN( "glVertexAttribI1uivEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI2i( GLuint index, GLint x, GLint y )
{
    struct glVertexAttribI2i_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttribI2i, &args ))) WARN( "glVertexAttribI2i returned %#lx\n", status );
}

static void WINAPI glVertexAttribI2iEXT( GLuint index, GLint x, GLint y )
{
    struct glVertexAttribI2iEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttribI2iEXT, &args ))) WARN( "glVertexAttribI2iEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI2iv( GLuint index, const GLint *v )
{
    struct glVertexAttribI2iv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI2iv, &args ))) WARN( "glVertexAttribI2iv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI2ivEXT( GLuint index, const GLint *v )
{
    struct glVertexAttribI2ivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI2ivEXT, &args ))) WARN( "glVertexAttribI2ivEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI2ui( GLuint index, GLuint x, GLuint y )
{
    struct glVertexAttribI2ui_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttribI2ui, &args ))) WARN( "glVertexAttribI2ui returned %#lx\n", status );
}

static void WINAPI glVertexAttribI2uiEXT( GLuint index, GLuint x, GLuint y )
{
    struct glVertexAttribI2uiEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttribI2uiEXT, &args ))) WARN( "glVertexAttribI2uiEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI2uiv( GLuint index, const GLuint *v )
{
    struct glVertexAttribI2uiv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI2uiv, &args ))) WARN( "glVertexAttribI2uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI2uivEXT( GLuint index, const GLuint *v )
{
    struct glVertexAttribI2uivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI2uivEXT, &args ))) WARN( "glVertexAttribI2uivEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI3i( GLuint index, GLint x, GLint y, GLint z )
{
    struct glVertexAttribI3i_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttribI3i, &args ))) WARN( "glVertexAttribI3i returned %#lx\n", status );
}

static void WINAPI glVertexAttribI3iEXT( GLuint index, GLint x, GLint y, GLint z )
{
    struct glVertexAttribI3iEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttribI3iEXT, &args ))) WARN( "glVertexAttribI3iEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI3iv( GLuint index, const GLint *v )
{
    struct glVertexAttribI3iv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI3iv, &args ))) WARN( "glVertexAttribI3iv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI3ivEXT( GLuint index, const GLint *v )
{
    struct glVertexAttribI3ivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI3ivEXT, &args ))) WARN( "glVertexAttribI3ivEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI3ui( GLuint index, GLuint x, GLuint y, GLuint z )
{
    struct glVertexAttribI3ui_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttribI3ui, &args ))) WARN( "glVertexAttribI3ui returned %#lx\n", status );
}

static void WINAPI glVertexAttribI3uiEXT( GLuint index, GLuint x, GLuint y, GLuint z )
{
    struct glVertexAttribI3uiEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttribI3uiEXT, &args ))) WARN( "glVertexAttribI3uiEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI3uiv( GLuint index, const GLuint *v )
{
    struct glVertexAttribI3uiv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI3uiv, &args ))) WARN( "glVertexAttribI3uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI3uivEXT( GLuint index, const GLuint *v )
{
    struct glVertexAttribI3uivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI3uivEXT, &args ))) WARN( "glVertexAttribI3uivEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4bv( GLuint index, const GLbyte *v )
{
    struct glVertexAttribI4bv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4bv, &args ))) WARN( "glVertexAttribI4bv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4bvEXT( GLuint index, const GLbyte *v )
{
    struct glVertexAttribI4bvEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4bvEXT, &args ))) WARN( "glVertexAttribI4bvEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w )
{
    struct glVertexAttribI4i_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttribI4i, &args ))) WARN( "glVertexAttribI4i returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4iEXT( GLuint index, GLint x, GLint y, GLint z, GLint w )
{
    struct glVertexAttribI4iEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttribI4iEXT, &args ))) WARN( "glVertexAttribI4iEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4iv( GLuint index, const GLint *v )
{
    struct glVertexAttribI4iv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4iv, &args ))) WARN( "glVertexAttribI4iv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4ivEXT( GLuint index, const GLint *v )
{
    struct glVertexAttribI4ivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4ivEXT, &args ))) WARN( "glVertexAttribI4ivEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4sv( GLuint index, const GLshort *v )
{
    struct glVertexAttribI4sv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4sv, &args ))) WARN( "glVertexAttribI4sv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4svEXT( GLuint index, const GLshort *v )
{
    struct glVertexAttribI4svEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4svEXT, &args ))) WARN( "glVertexAttribI4svEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4ubv( GLuint index, const GLubyte *v )
{
    struct glVertexAttribI4ubv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4ubv, &args ))) WARN( "glVertexAttribI4ubv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4ubvEXT( GLuint index, const GLubyte *v )
{
    struct glVertexAttribI4ubvEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4ubvEXT, &args ))) WARN( "glVertexAttribI4ubvEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
{
    struct glVertexAttribI4ui_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttribI4ui, &args ))) WARN( "glVertexAttribI4ui returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4uiEXT( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
{
    struct glVertexAttribI4uiEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %d, y %d, z %d, w %d\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttribI4uiEXT, &args ))) WARN( "glVertexAttribI4uiEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4uiv( GLuint index, const GLuint *v )
{
    struct glVertexAttribI4uiv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4uiv, &args ))) WARN( "glVertexAttribI4uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4uivEXT( GLuint index, const GLuint *v )
{
    struct glVertexAttribI4uivEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4uivEXT, &args ))) WARN( "glVertexAttribI4uivEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4usv( GLuint index, const GLushort *v )
{
    struct glVertexAttribI4usv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4usv, &args ))) WARN( "glVertexAttribI4usv returned %#lx\n", status );
}

static void WINAPI glVertexAttribI4usvEXT( GLuint index, const GLushort *v )
{
    struct glVertexAttribI4usvEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribI4usvEXT, &args ))) WARN( "glVertexAttribI4usvEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribIFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
{
    struct glVertexAttribIFormat_params args = { .teb = NtCurrentTeb(), .attribindex = attribindex, .size = size, .type = type, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "attribindex %d, size %d, type %d, relativeoffset %d\n", attribindex, size, type, relativeoffset );
    if ((status = UNIX_CALL( glVertexAttribIFormat, &args ))) WARN( "glVertexAttribIFormat returned %#lx\n", status );
}

static void WINAPI glVertexAttribIFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride )
{
    struct glVertexAttribIFormatNV_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, stride %d\n", index, size, type, stride );
    if ((status = UNIX_CALL( glVertexAttribIFormatNV, &args ))) WARN( "glVertexAttribIFormatNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glVertexAttribIPointer_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, stride %d, pointer %p\n", index, size, type, stride, pointer );
    if ((status = UNIX_CALL( glVertexAttribIPointer, &args ))) WARN( "glVertexAttribIPointer returned %#lx\n", status );
}

static void WINAPI glVertexAttribIPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glVertexAttribIPointerEXT_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, stride %d, pointer %p\n", index, size, type, stride, pointer );
    if ((status = UNIX_CALL( glVertexAttribIPointerEXT, &args ))) WARN( "glVertexAttribIPointerEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1d( GLuint index, GLdouble x )
{
    struct glVertexAttribL1d_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %f\n", index, x );
    if ((status = UNIX_CALL( glVertexAttribL1d, &args ))) WARN( "glVertexAttribL1d returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1dEXT( GLuint index, GLdouble x )
{
    struct glVertexAttribL1dEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %f\n", index, x );
    if ((status = UNIX_CALL( glVertexAttribL1dEXT, &args ))) WARN( "glVertexAttribL1dEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1dv( GLuint index, const GLdouble *v )
{
    struct glVertexAttribL1dv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL1dv, &args ))) WARN( "glVertexAttribL1dv returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1dvEXT( GLuint index, const GLdouble *v )
{
    struct glVertexAttribL1dvEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL1dvEXT, &args ))) WARN( "glVertexAttribL1dvEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1i64NV( GLuint index, GLint64EXT x )
{
    struct glVertexAttribL1i64NV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %s\n", index, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glVertexAttribL1i64NV, &args ))) WARN( "glVertexAttribL1i64NV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1i64vNV( GLuint index, const GLint64EXT *v )
{
    struct glVertexAttribL1i64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL1i64vNV, &args ))) WARN( "glVertexAttribL1i64vNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1ui64ARB( GLuint index, GLuint64EXT x )
{
    struct glVertexAttribL1ui64ARB_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %s\n", index, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glVertexAttribL1ui64ARB, &args ))) WARN( "glVertexAttribL1ui64ARB returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1ui64NV( GLuint index, GLuint64EXT x )
{
    struct glVertexAttribL1ui64NV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x };
    NTSTATUS status;
    TRACE( "index %d, x %s\n", index, wine_dbgstr_longlong(x) );
    if ((status = UNIX_CALL( glVertexAttribL1ui64NV, &args ))) WARN( "glVertexAttribL1ui64NV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1ui64vARB( GLuint index, const GLuint64EXT *v )
{
    struct glVertexAttribL1ui64vARB_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL1ui64vARB, &args ))) WARN( "glVertexAttribL1ui64vARB returned %#lx\n", status );
}

static void WINAPI glVertexAttribL1ui64vNV( GLuint index, const GLuint64EXT *v )
{
    struct glVertexAttribL1ui64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL1ui64vNV, &args ))) WARN( "glVertexAttribL1ui64vNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL2d( GLuint index, GLdouble x, GLdouble y )
{
    struct glVertexAttribL2d_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttribL2d, &args ))) WARN( "glVertexAttribL2d returned %#lx\n", status );
}

static void WINAPI glVertexAttribL2dEXT( GLuint index, GLdouble x, GLdouble y )
{
    struct glVertexAttribL2dEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f\n", index, x, y );
    if ((status = UNIX_CALL( glVertexAttribL2dEXT, &args ))) WARN( "glVertexAttribL2dEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL2dv( GLuint index, const GLdouble *v )
{
    struct glVertexAttribL2dv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL2dv, &args ))) WARN( "glVertexAttribL2dv returned %#lx\n", status );
}

static void WINAPI glVertexAttribL2dvEXT( GLuint index, const GLdouble *v )
{
    struct glVertexAttribL2dvEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL2dvEXT, &args ))) WARN( "glVertexAttribL2dvEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL2i64NV( GLuint index, GLint64EXT x, GLint64EXT y )
{
    struct glVertexAttribL2i64NV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %s, y %s\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glVertexAttribL2i64NV, &args ))) WARN( "glVertexAttribL2i64NV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL2i64vNV( GLuint index, const GLint64EXT *v )
{
    struct glVertexAttribL2i64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL2i64vNV, &args ))) WARN( "glVertexAttribL2i64vNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL2ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y )
{
    struct glVertexAttribL2ui64NV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "index %d, x %s, y %s\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
    if ((status = UNIX_CALL( glVertexAttribL2ui64NV, &args ))) WARN( "glVertexAttribL2ui64NV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL2ui64vNV( GLuint index, const GLuint64EXT *v )
{
    struct glVertexAttribL2ui64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL2ui64vNV, &args ))) WARN( "glVertexAttribL2ui64vNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL3d( GLuint index, GLdouble x, GLdouble y, GLdouble z )
{
    struct glVertexAttribL3d_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttribL3d, &args ))) WARN( "glVertexAttribL3d returned %#lx\n", status );
}

static void WINAPI glVertexAttribL3dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z )
{
    struct glVertexAttribL3dEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f\n", index, x, y, z );
    if ((status = UNIX_CALL( glVertexAttribL3dEXT, &args ))) WARN( "glVertexAttribL3dEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL3dv( GLuint index, const GLdouble *v )
{
    struct glVertexAttribL3dv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL3dv, &args ))) WARN( "glVertexAttribL3dv returned %#lx\n", status );
}

static void WINAPI glVertexAttribL3dvEXT( GLuint index, const GLdouble *v )
{
    struct glVertexAttribL3dvEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL3dvEXT, &args ))) WARN( "glVertexAttribL3dvEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL3i64NV( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z )
{
    struct glVertexAttribL3i64NV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %s, y %s, z %s\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glVertexAttribL3i64NV, &args ))) WARN( "glVertexAttribL3i64NV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL3i64vNV( GLuint index, const GLint64EXT *v )
{
    struct glVertexAttribL3i64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL3i64vNV, &args ))) WARN( "glVertexAttribL3i64vNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL3ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z )
{
    struct glVertexAttribL3ui64NV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "index %d, x %s, y %s, z %s\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
    if ((status = UNIX_CALL( glVertexAttribL3ui64NV, &args ))) WARN( "glVertexAttribL3ui64NV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL3ui64vNV( GLuint index, const GLuint64EXT *v )
{
    struct glVertexAttribL3ui64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL3ui64vNV, &args ))) WARN( "glVertexAttribL3ui64vNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glVertexAttribL4d_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f, w %f\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttribL4d, &args ))) WARN( "glVertexAttribL4d returned %#lx\n", status );
}

static void WINAPI glVertexAttribL4dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glVertexAttribL4dEXT_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, z %f, w %f\n", index, x, y, z, w );
    if ((status = UNIX_CALL( glVertexAttribL4dEXT, &args ))) WARN( "glVertexAttribL4dEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL4dv( GLuint index, const GLdouble *v )
{
    struct glVertexAttribL4dv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL4dv, &args ))) WARN( "glVertexAttribL4dv returned %#lx\n", status );
}

static void WINAPI glVertexAttribL4dvEXT( GLuint index, const GLdouble *v )
{
    struct glVertexAttribL4dvEXT_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL4dvEXT, &args ))) WARN( "glVertexAttribL4dvEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribL4i64NV( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w )
{
    struct glVertexAttribL4i64NV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %s, y %s, z %s, w %s\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glVertexAttribL4i64NV, &args ))) WARN( "glVertexAttribL4i64NV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL4i64vNV( GLuint index, const GLint64EXT *v )
{
    struct glVertexAttribL4i64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL4i64vNV, &args ))) WARN( "glVertexAttribL4i64vNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL4ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w )
{
    struct glVertexAttribL4ui64NV_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "index %d, x %s, y %s, z %s, w %s\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
    if ((status = UNIX_CALL( glVertexAttribL4ui64NV, &args ))) WARN( "glVertexAttribL4ui64NV returned %#lx\n", status );
}

static void WINAPI glVertexAttribL4ui64vNV( GLuint index, const GLuint64EXT *v )
{
    struct glVertexAttribL4ui64vNV_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glVertexAttribL4ui64vNV, &args ))) WARN( "glVertexAttribL4ui64vNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribLFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
{
    struct glVertexAttribLFormat_params args = { .teb = NtCurrentTeb(), .attribindex = attribindex, .size = size, .type = type, .relativeoffset = relativeoffset };
    NTSTATUS status;
    TRACE( "attribindex %d, size %d, type %d, relativeoffset %d\n", attribindex, size, type, relativeoffset );
    if ((status = UNIX_CALL( glVertexAttribLFormat, &args ))) WARN( "glVertexAttribLFormat returned %#lx\n", status );
}

static void WINAPI glVertexAttribLFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride )
{
    struct glVertexAttribLFormatNV_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, stride %d\n", index, size, type, stride );
    if ((status = UNIX_CALL( glVertexAttribLFormatNV, &args ))) WARN( "glVertexAttribLFormatNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribLPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glVertexAttribLPointer_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, stride %d, pointer %p\n", index, size, type, stride, pointer );
    if ((status = UNIX_CALL( glVertexAttribLPointer, &args ))) WARN( "glVertexAttribLPointer returned %#lx\n", status );
}

static void WINAPI glVertexAttribLPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glVertexAttribLPointerEXT_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, stride %d, pointer %p\n", index, size, type, stride, pointer );
    if ((status = UNIX_CALL( glVertexAttribLPointerEXT, &args ))) WARN( "glVertexAttribLPointerEXT returned %#lx\n", status );
}

static void WINAPI glVertexAttribP1ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
{
    struct glVertexAttribP1ui_params args = { .teb = NtCurrentTeb(), .index = index, .type = type, .normalized = normalized, .value = value };
    NTSTATUS status;
    TRACE( "index %d, type %d, normalized %d, value %d\n", index, type, normalized, value );
    if ((status = UNIX_CALL( glVertexAttribP1ui, &args ))) WARN( "glVertexAttribP1ui returned %#lx\n", status );
}

static void WINAPI glVertexAttribP1uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value )
{
    struct glVertexAttribP1uiv_params args = { .teb = NtCurrentTeb(), .index = index, .type = type, .normalized = normalized, .value = value };
    NTSTATUS status;
    TRACE( "index %d, type %d, normalized %d, value %p\n", index, type, normalized, value );
    if ((status = UNIX_CALL( glVertexAttribP1uiv, &args ))) WARN( "glVertexAttribP1uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttribP2ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
{
    struct glVertexAttribP2ui_params args = { .teb = NtCurrentTeb(), .index = index, .type = type, .normalized = normalized, .value = value };
    NTSTATUS status;
    TRACE( "index %d, type %d, normalized %d, value %d\n", index, type, normalized, value );
    if ((status = UNIX_CALL( glVertexAttribP2ui, &args ))) WARN( "glVertexAttribP2ui returned %#lx\n", status );
}

static void WINAPI glVertexAttribP2uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value )
{
    struct glVertexAttribP2uiv_params args = { .teb = NtCurrentTeb(), .index = index, .type = type, .normalized = normalized, .value = value };
    NTSTATUS status;
    TRACE( "index %d, type %d, normalized %d, value %p\n", index, type, normalized, value );
    if ((status = UNIX_CALL( glVertexAttribP2uiv, &args ))) WARN( "glVertexAttribP2uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttribP3ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
{
    struct glVertexAttribP3ui_params args = { .teb = NtCurrentTeb(), .index = index, .type = type, .normalized = normalized, .value = value };
    NTSTATUS status;
    TRACE( "index %d, type %d, normalized %d, value %d\n", index, type, normalized, value );
    if ((status = UNIX_CALL( glVertexAttribP3ui, &args ))) WARN( "glVertexAttribP3ui returned %#lx\n", status );
}

static void WINAPI glVertexAttribP3uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value )
{
    struct glVertexAttribP3uiv_params args = { .teb = NtCurrentTeb(), .index = index, .type = type, .normalized = normalized, .value = value };
    NTSTATUS status;
    TRACE( "index %d, type %d, normalized %d, value %p\n", index, type, normalized, value );
    if ((status = UNIX_CALL( glVertexAttribP3uiv, &args ))) WARN( "glVertexAttribP3uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttribP4ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
{
    struct glVertexAttribP4ui_params args = { .teb = NtCurrentTeb(), .index = index, .type = type, .normalized = normalized, .value = value };
    NTSTATUS status;
    TRACE( "index %d, type %d, normalized %d, value %d\n", index, type, normalized, value );
    if ((status = UNIX_CALL( glVertexAttribP4ui, &args ))) WARN( "glVertexAttribP4ui returned %#lx\n", status );
}

static void WINAPI glVertexAttribP4uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value )
{
    struct glVertexAttribP4uiv_params args = { .teb = NtCurrentTeb(), .index = index, .type = type, .normalized = normalized, .value = value };
    NTSTATUS status;
    TRACE( "index %d, type %d, normalized %d, value %p\n", index, type, normalized, value );
    if ((status = UNIX_CALL( glVertexAttribP4uiv, &args ))) WARN( "glVertexAttribP4uiv returned %#lx\n", status );
}

static void WINAPI glVertexAttribParameteriAMD( GLuint index, GLenum pname, GLint param )
{
    struct glVertexAttribParameteriAMD_params args = { .teb = NtCurrentTeb(), .index = index, .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "index %d, pname %d, param %d\n", index, pname, param );
    if ((status = UNIX_CALL( glVertexAttribParameteriAMD, &args ))) WARN( "glVertexAttribParameteriAMD returned %#lx\n", status );
}

static void WINAPI glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer )
{
    struct glVertexAttribPointer_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .normalized = normalized, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, normalized %d, stride %d, pointer %p\n", index, size, type, normalized, stride, pointer );
    if ((status = UNIX_CALL( glVertexAttribPointer, &args ))) WARN( "glVertexAttribPointer returned %#lx\n", status );
}

static void WINAPI glVertexAttribPointerARB( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer )
{
    struct glVertexAttribPointerARB_params args = { .teb = NtCurrentTeb(), .index = index, .size = size, .type = type, .normalized = normalized, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, size %d, type %d, normalized %d, stride %d, pointer %p\n", index, size, type, normalized, stride, pointer );
    if ((status = UNIX_CALL( glVertexAttribPointerARB, &args ))) WARN( "glVertexAttribPointerARB returned %#lx\n", status );
}

static void WINAPI glVertexAttribPointerNV( GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer )
{
    struct glVertexAttribPointerNV_params args = { .teb = NtCurrentTeb(), .index = index, .fsize = fsize, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "index %d, fsize %d, type %d, stride %d, pointer %p\n", index, fsize, type, stride, pointer );
    if ((status = UNIX_CALL( glVertexAttribPointerNV, &args ))) WARN( "glVertexAttribPointerNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs1dvNV( GLuint index, GLsizei count, const GLdouble *v )
{
    struct glVertexAttribs1dvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs1dvNV, &args ))) WARN( "glVertexAttribs1dvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs1fvNV( GLuint index, GLsizei count, const GLfloat *v )
{
    struct glVertexAttribs1fvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs1fvNV, &args ))) WARN( "glVertexAttribs1fvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs1hvNV( GLuint index, GLsizei n, const GLhalfNV *v )
{
    struct glVertexAttribs1hvNV_params args = { .teb = NtCurrentTeb(), .index = index, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "index %d, n %d, v %p\n", index, n, v );
    if ((status = UNIX_CALL( glVertexAttribs1hvNV, &args ))) WARN( "glVertexAttribs1hvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs1svNV( GLuint index, GLsizei count, const GLshort *v )
{
    struct glVertexAttribs1svNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs1svNV, &args ))) WARN( "glVertexAttribs1svNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs2dvNV( GLuint index, GLsizei count, const GLdouble *v )
{
    struct glVertexAttribs2dvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs2dvNV, &args ))) WARN( "glVertexAttribs2dvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs2fvNV( GLuint index, GLsizei count, const GLfloat *v )
{
    struct glVertexAttribs2fvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs2fvNV, &args ))) WARN( "glVertexAttribs2fvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs2hvNV( GLuint index, GLsizei n, const GLhalfNV *v )
{
    struct glVertexAttribs2hvNV_params args = { .teb = NtCurrentTeb(), .index = index, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "index %d, n %d, v %p\n", index, n, v );
    if ((status = UNIX_CALL( glVertexAttribs2hvNV, &args ))) WARN( "glVertexAttribs2hvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs2svNV( GLuint index, GLsizei count, const GLshort *v )
{
    struct glVertexAttribs2svNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs2svNV, &args ))) WARN( "glVertexAttribs2svNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs3dvNV( GLuint index, GLsizei count, const GLdouble *v )
{
    struct glVertexAttribs3dvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs3dvNV, &args ))) WARN( "glVertexAttribs3dvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs3fvNV( GLuint index, GLsizei count, const GLfloat *v )
{
    struct glVertexAttribs3fvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs3fvNV, &args ))) WARN( "glVertexAttribs3fvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs3hvNV( GLuint index, GLsizei n, const GLhalfNV *v )
{
    struct glVertexAttribs3hvNV_params args = { .teb = NtCurrentTeb(), .index = index, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "index %d, n %d, v %p\n", index, n, v );
    if ((status = UNIX_CALL( glVertexAttribs3hvNV, &args ))) WARN( "glVertexAttribs3hvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs3svNV( GLuint index, GLsizei count, const GLshort *v )
{
    struct glVertexAttribs3svNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs3svNV, &args ))) WARN( "glVertexAttribs3svNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs4dvNV( GLuint index, GLsizei count, const GLdouble *v )
{
    struct glVertexAttribs4dvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs4dvNV, &args ))) WARN( "glVertexAttribs4dvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs4fvNV( GLuint index, GLsizei count, const GLfloat *v )
{
    struct glVertexAttribs4fvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs4fvNV, &args ))) WARN( "glVertexAttribs4fvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs4hvNV( GLuint index, GLsizei n, const GLhalfNV *v )
{
    struct glVertexAttribs4hvNV_params args = { .teb = NtCurrentTeb(), .index = index, .n = n, .v = v };
    NTSTATUS status;
    TRACE( "index %d, n %d, v %p\n", index, n, v );
    if ((status = UNIX_CALL( glVertexAttribs4hvNV, &args ))) WARN( "glVertexAttribs4hvNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs4svNV( GLuint index, GLsizei count, const GLshort *v )
{
    struct glVertexAttribs4svNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs4svNV, &args ))) WARN( "glVertexAttribs4svNV returned %#lx\n", status );
}

static void WINAPI glVertexAttribs4ubvNV( GLuint index, GLsizei count, const GLubyte *v )
{
    struct glVertexAttribs4ubvNV_params args = { .teb = NtCurrentTeb(), .index = index, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "index %d, count %d, v %p\n", index, count, v );
    if ((status = UNIX_CALL( glVertexAttribs4ubvNV, &args ))) WARN( "glVertexAttribs4ubvNV returned %#lx\n", status );
}

static void WINAPI glVertexBindingDivisor( GLuint bindingindex, GLuint divisor )
{
    struct glVertexBindingDivisor_params args = { .teb = NtCurrentTeb(), .bindingindex = bindingindex, .divisor = divisor };
    NTSTATUS status;
    TRACE( "bindingindex %d, divisor %d\n", bindingindex, divisor );
    if ((status = UNIX_CALL( glVertexBindingDivisor, &args ))) WARN( "glVertexBindingDivisor returned %#lx\n", status );
}

static void WINAPI glVertexBlendARB( GLint count )
{
    struct glVertexBlendARB_params args = { .teb = NtCurrentTeb(), .count = count };
    NTSTATUS status;
    TRACE( "count %d\n", count );
    if ((status = UNIX_CALL( glVertexBlendARB, &args ))) WARN( "glVertexBlendARB returned %#lx\n", status );
}

static void WINAPI glVertexBlendEnvfATI( GLenum pname, GLfloat param )
{
    struct glVertexBlendEnvfATI_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %f\n", pname, param );
    if ((status = UNIX_CALL( glVertexBlendEnvfATI, &args ))) WARN( "glVertexBlendEnvfATI returned %#lx\n", status );
}

static void WINAPI glVertexBlendEnviATI( GLenum pname, GLint param )
{
    struct glVertexBlendEnviATI_params args = { .teb = NtCurrentTeb(), .pname = pname, .param = param };
    NTSTATUS status;
    TRACE( "pname %d, param %d\n", pname, param );
    if ((status = UNIX_CALL( glVertexBlendEnviATI, &args ))) WARN( "glVertexBlendEnviATI returned %#lx\n", status );
}

static void WINAPI glVertexFormatNV( GLint size, GLenum type, GLsizei stride )
{
    struct glVertexFormatNV_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d\n", size, type, stride );
    if ((status = UNIX_CALL( glVertexFormatNV, &args ))) WARN( "glVertexFormatNV returned %#lx\n", status );
}

static void WINAPI glVertexP2ui( GLenum type, GLuint value )
{
    struct glVertexP2ui_params args = { .teb = NtCurrentTeb(), .type = type, .value = value };
    NTSTATUS status;
    TRACE( "type %d, value %d\n", type, value );
    if ((status = UNIX_CALL( glVertexP2ui, &args ))) WARN( "glVertexP2ui returned %#lx\n", status );
}

static void WINAPI glVertexP2uiv( GLenum type, const GLuint *value )
{
    struct glVertexP2uiv_params args = { .teb = NtCurrentTeb(), .type = type, .value = value };
    NTSTATUS status;
    TRACE( "type %d, value %p\n", type, value );
    if ((status = UNIX_CALL( glVertexP2uiv, &args ))) WARN( "glVertexP2uiv returned %#lx\n", status );
}

static void WINAPI glVertexP3ui( GLenum type, GLuint value )
{
    struct glVertexP3ui_params args = { .teb = NtCurrentTeb(), .type = type, .value = value };
    NTSTATUS status;
    TRACE( "type %d, value %d\n", type, value );
    if ((status = UNIX_CALL( glVertexP3ui, &args ))) WARN( "glVertexP3ui returned %#lx\n", status );
}

static void WINAPI glVertexP3uiv( GLenum type, const GLuint *value )
{
    struct glVertexP3uiv_params args = { .teb = NtCurrentTeb(), .type = type, .value = value };
    NTSTATUS status;
    TRACE( "type %d, value %p\n", type, value );
    if ((status = UNIX_CALL( glVertexP3uiv, &args ))) WARN( "glVertexP3uiv returned %#lx\n", status );
}

static void WINAPI glVertexP4ui( GLenum type, GLuint value )
{
    struct glVertexP4ui_params args = { .teb = NtCurrentTeb(), .type = type, .value = value };
    NTSTATUS status;
    TRACE( "type %d, value %d\n", type, value );
    if ((status = UNIX_CALL( glVertexP4ui, &args ))) WARN( "glVertexP4ui returned %#lx\n", status );
}

static void WINAPI glVertexP4uiv( GLenum type, const GLuint *value )
{
    struct glVertexP4uiv_params args = { .teb = NtCurrentTeb(), .type = type, .value = value };
    NTSTATUS status;
    TRACE( "type %d, value %p\n", type, value );
    if ((status = UNIX_CALL( glVertexP4uiv, &args ))) WARN( "glVertexP4uiv returned %#lx\n", status );
}

static void WINAPI glVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer )
{
    struct glVertexPointerEXT_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .count = count, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, count %d, pointer %p\n", size, type, stride, count, pointer );
    if ((status = UNIX_CALL( glVertexPointerEXT, &args ))) WARN( "glVertexPointerEXT returned %#lx\n", status );
}

static void WINAPI glVertexPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride )
{
    struct glVertexPointerListIBM_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer, .ptrstride = ptrstride };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p, ptrstride %d\n", size, type, stride, pointer, ptrstride );
    if ((status = UNIX_CALL( glVertexPointerListIBM, &args ))) WARN( "glVertexPointerListIBM returned %#lx\n", status );
}

static void WINAPI glVertexPointervINTEL( GLint size, GLenum type, const void **pointer )
{
    struct glVertexPointervINTEL_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, pointer %p\n", size, type, pointer );
    if ((status = UNIX_CALL( glVertexPointervINTEL, &args ))) WARN( "glVertexPointervINTEL returned %#lx\n", status );
}

static void WINAPI glVertexStream1dATI( GLenum stream, GLdouble x )
{
    struct glVertexStream1dATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x };
    NTSTATUS status;
    TRACE( "stream %d, x %f\n", stream, x );
    if ((status = UNIX_CALL( glVertexStream1dATI, &args ))) WARN( "glVertexStream1dATI returned %#lx\n", status );
}

static void WINAPI glVertexStream1dvATI( GLenum stream, const GLdouble *coords )
{
    struct glVertexStream1dvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream1dvATI, &args ))) WARN( "glVertexStream1dvATI returned %#lx\n", status );
}

static void WINAPI glVertexStream1fATI( GLenum stream, GLfloat x )
{
    struct glVertexStream1fATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x };
    NTSTATUS status;
    TRACE( "stream %d, x %f\n", stream, x );
    if ((status = UNIX_CALL( glVertexStream1fATI, &args ))) WARN( "glVertexStream1fATI returned %#lx\n", status );
}

static void WINAPI glVertexStream1fvATI( GLenum stream, const GLfloat *coords )
{
    struct glVertexStream1fvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream1fvATI, &args ))) WARN( "glVertexStream1fvATI returned %#lx\n", status );
}

static void WINAPI glVertexStream1iATI( GLenum stream, GLint x )
{
    struct glVertexStream1iATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x };
    NTSTATUS status;
    TRACE( "stream %d, x %d\n", stream, x );
    if ((status = UNIX_CALL( glVertexStream1iATI, &args ))) WARN( "glVertexStream1iATI returned %#lx\n", status );
}

static void WINAPI glVertexStream1ivATI( GLenum stream, const GLint *coords )
{
    struct glVertexStream1ivATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream1ivATI, &args ))) WARN( "glVertexStream1ivATI returned %#lx\n", status );
}

static void WINAPI glVertexStream1sATI( GLenum stream, GLshort x )
{
    struct glVertexStream1sATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x };
    NTSTATUS status;
    TRACE( "stream %d, x %d\n", stream, x );
    if ((status = UNIX_CALL( glVertexStream1sATI, &args ))) WARN( "glVertexStream1sATI returned %#lx\n", status );
}

static void WINAPI glVertexStream1svATI( GLenum stream, const GLshort *coords )
{
    struct glVertexStream1svATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream1svATI, &args ))) WARN( "glVertexStream1svATI returned %#lx\n", status );
}

static void WINAPI glVertexStream2dATI( GLenum stream, GLdouble x, GLdouble y )
{
    struct glVertexStream2dATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "stream %d, x %f, y %f\n", stream, x, y );
    if ((status = UNIX_CALL( glVertexStream2dATI, &args ))) WARN( "glVertexStream2dATI returned %#lx\n", status );
}

static void WINAPI glVertexStream2dvATI( GLenum stream, const GLdouble *coords )
{
    struct glVertexStream2dvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream2dvATI, &args ))) WARN( "glVertexStream2dvATI returned %#lx\n", status );
}

static void WINAPI glVertexStream2fATI( GLenum stream, GLfloat x, GLfloat y )
{
    struct glVertexStream2fATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "stream %d, x %f, y %f\n", stream, x, y );
    if ((status = UNIX_CALL( glVertexStream2fATI, &args ))) WARN( "glVertexStream2fATI returned %#lx\n", status );
}

static void WINAPI glVertexStream2fvATI( GLenum stream, const GLfloat *coords )
{
    struct glVertexStream2fvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream2fvATI, &args ))) WARN( "glVertexStream2fvATI returned %#lx\n", status );
}

static void WINAPI glVertexStream2iATI( GLenum stream, GLint x, GLint y )
{
    struct glVertexStream2iATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "stream %d, x %d, y %d\n", stream, x, y );
    if ((status = UNIX_CALL( glVertexStream2iATI, &args ))) WARN( "glVertexStream2iATI returned %#lx\n", status );
}

static void WINAPI glVertexStream2ivATI( GLenum stream, const GLint *coords )
{
    struct glVertexStream2ivATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream2ivATI, &args ))) WARN( "glVertexStream2ivATI returned %#lx\n", status );
}

static void WINAPI glVertexStream2sATI( GLenum stream, GLshort x, GLshort y )
{
    struct glVertexStream2sATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y };
    NTSTATUS status;
    TRACE( "stream %d, x %d, y %d\n", stream, x, y );
    if ((status = UNIX_CALL( glVertexStream2sATI, &args ))) WARN( "glVertexStream2sATI returned %#lx\n", status );
}

static void WINAPI glVertexStream2svATI( GLenum stream, const GLshort *coords )
{
    struct glVertexStream2svATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream2svATI, &args ))) WARN( "glVertexStream2svATI returned %#lx\n", status );
}

static void WINAPI glVertexStream3dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z )
{
    struct glVertexStream3dATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "stream %d, x %f, y %f, z %f\n", stream, x, y, z );
    if ((status = UNIX_CALL( glVertexStream3dATI, &args ))) WARN( "glVertexStream3dATI returned %#lx\n", status );
}

static void WINAPI glVertexStream3dvATI( GLenum stream, const GLdouble *coords )
{
    struct glVertexStream3dvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream3dvATI, &args ))) WARN( "glVertexStream3dvATI returned %#lx\n", status );
}

static void WINAPI glVertexStream3fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z )
{
    struct glVertexStream3fATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "stream %d, x %f, y %f, z %f\n", stream, x, y, z );
    if ((status = UNIX_CALL( glVertexStream3fATI, &args ))) WARN( "glVertexStream3fATI returned %#lx\n", status );
}

static void WINAPI glVertexStream3fvATI( GLenum stream, const GLfloat *coords )
{
    struct glVertexStream3fvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream3fvATI, &args ))) WARN( "glVertexStream3fvATI returned %#lx\n", status );
}

static void WINAPI glVertexStream3iATI( GLenum stream, GLint x, GLint y, GLint z )
{
    struct glVertexStream3iATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "stream %d, x %d, y %d, z %d\n", stream, x, y, z );
    if ((status = UNIX_CALL( glVertexStream3iATI, &args ))) WARN( "glVertexStream3iATI returned %#lx\n", status );
}

static void WINAPI glVertexStream3ivATI( GLenum stream, const GLint *coords )
{
    struct glVertexStream3ivATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream3ivATI, &args ))) WARN( "glVertexStream3ivATI returned %#lx\n", status );
}

static void WINAPI glVertexStream3sATI( GLenum stream, GLshort x, GLshort y, GLshort z )
{
    struct glVertexStream3sATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "stream %d, x %d, y %d, z %d\n", stream, x, y, z );
    if ((status = UNIX_CALL( glVertexStream3sATI, &args ))) WARN( "glVertexStream3sATI returned %#lx\n", status );
}

static void WINAPI glVertexStream3svATI( GLenum stream, const GLshort *coords )
{
    struct glVertexStream3svATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream3svATI, &args ))) WARN( "glVertexStream3svATI returned %#lx\n", status );
}

static void WINAPI glVertexStream4dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glVertexStream4dATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "stream %d, x %f, y %f, z %f, w %f\n", stream, x, y, z, w );
    if ((status = UNIX_CALL( glVertexStream4dATI, &args ))) WARN( "glVertexStream4dATI returned %#lx\n", status );
}

static void WINAPI glVertexStream4dvATI( GLenum stream, const GLdouble *coords )
{
    struct glVertexStream4dvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream4dvATI, &args ))) WARN( "glVertexStream4dvATI returned %#lx\n", status );
}

static void WINAPI glVertexStream4fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glVertexStream4fATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "stream %d, x %f, y %f, z %f, w %f\n", stream, x, y, z, w );
    if ((status = UNIX_CALL( glVertexStream4fATI, &args ))) WARN( "glVertexStream4fATI returned %#lx\n", status );
}

static void WINAPI glVertexStream4fvATI( GLenum stream, const GLfloat *coords )
{
    struct glVertexStream4fvATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream4fvATI, &args ))) WARN( "glVertexStream4fvATI returned %#lx\n", status );
}

static void WINAPI glVertexStream4iATI( GLenum stream, GLint x, GLint y, GLint z, GLint w )
{
    struct glVertexStream4iATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "stream %d, x %d, y %d, z %d, w %d\n", stream, x, y, z, w );
    if ((status = UNIX_CALL( glVertexStream4iATI, &args ))) WARN( "glVertexStream4iATI returned %#lx\n", status );
}

static void WINAPI glVertexStream4ivATI( GLenum stream, const GLint *coords )
{
    struct glVertexStream4ivATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream4ivATI, &args ))) WARN( "glVertexStream4ivATI returned %#lx\n", status );
}

static void WINAPI glVertexStream4sATI( GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w )
{
    struct glVertexStream4sATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "stream %d, x %d, y %d, z %d, w %d\n", stream, x, y, z, w );
    if ((status = UNIX_CALL( glVertexStream4sATI, &args ))) WARN( "glVertexStream4sATI returned %#lx\n", status );
}

static void WINAPI glVertexStream4svATI( GLenum stream, const GLshort *coords )
{
    struct glVertexStream4svATI_params args = { .teb = NtCurrentTeb(), .stream = stream, .coords = coords };
    NTSTATUS status;
    TRACE( "stream %d, coords %p\n", stream, coords );
    if ((status = UNIX_CALL( glVertexStream4svATI, &args ))) WARN( "glVertexStream4svATI returned %#lx\n", status );
}

static void WINAPI glVertexWeightPointerEXT( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glVertexWeightPointerEXT_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
    if ((status = UNIX_CALL( glVertexWeightPointerEXT, &args ))) WARN( "glVertexWeightPointerEXT returned %#lx\n", status );
}

static void WINAPI glVertexWeightfEXT( GLfloat weight )
{
    struct glVertexWeightfEXT_params args = { .teb = NtCurrentTeb(), .weight = weight };
    NTSTATUS status;
    TRACE( "weight %f\n", weight );
    if ((status = UNIX_CALL( glVertexWeightfEXT, &args ))) WARN( "glVertexWeightfEXT returned %#lx\n", status );
}

static void WINAPI glVertexWeightfvEXT( const GLfloat *weight )
{
    struct glVertexWeightfvEXT_params args = { .teb = NtCurrentTeb(), .weight = weight };
    NTSTATUS status;
    TRACE( "weight %p\n", weight );
    if ((status = UNIX_CALL( glVertexWeightfvEXT, &args ))) WARN( "glVertexWeightfvEXT returned %#lx\n", status );
}

static void WINAPI glVertexWeighthNV( GLhalfNV weight )
{
    struct glVertexWeighthNV_params args = { .teb = NtCurrentTeb(), .weight = weight };
    NTSTATUS status;
    TRACE( "weight %d\n", weight );
    if ((status = UNIX_CALL( glVertexWeighthNV, &args ))) WARN( "glVertexWeighthNV returned %#lx\n", status );
}

static void WINAPI glVertexWeighthvNV( const GLhalfNV *weight )
{
    struct glVertexWeighthvNV_params args = { .teb = NtCurrentTeb(), .weight = weight };
    NTSTATUS status;
    TRACE( "weight %p\n", weight );
    if ((status = UNIX_CALL( glVertexWeighthvNV, &args ))) WARN( "glVertexWeighthvNV returned %#lx\n", status );
}

static GLenum WINAPI glVideoCaptureNV( GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time )
{
    struct glVideoCaptureNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .sequence_num = sequence_num, .capture_time = capture_time };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, sequence_num %p, capture_time %p\n", video_capture_slot, sequence_num, capture_time );
    if ((status = UNIX_CALL( glVideoCaptureNV, &args ))) WARN( "glVideoCaptureNV returned %#lx\n", status );
    return args.ret;
}

static void WINAPI glVideoCaptureStreamParameterdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params )
{
    struct glVideoCaptureStreamParameterdvNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .stream = stream, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, stream %d, pname %d, params %p\n", video_capture_slot, stream, pname, params );
    if ((status = UNIX_CALL( glVideoCaptureStreamParameterdvNV, &args ))) WARN( "glVideoCaptureStreamParameterdvNV returned %#lx\n", status );
}

static void WINAPI glVideoCaptureStreamParameterfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params )
{
    struct glVideoCaptureStreamParameterfvNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .stream = stream, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, stream %d, pname %d, params %p\n", video_capture_slot, stream, pname, params );
    if ((status = UNIX_CALL( glVideoCaptureStreamParameterfvNV, &args ))) WARN( "glVideoCaptureStreamParameterfvNV returned %#lx\n", status );
}

static void WINAPI glVideoCaptureStreamParameterivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params )
{
    struct glVideoCaptureStreamParameterivNV_params args = { .teb = NtCurrentTeb(), .video_capture_slot = video_capture_slot, .stream = stream, .pname = pname, .params = params };
    NTSTATUS status;
    TRACE( "video_capture_slot %d, stream %d, pname %d, params %p\n", video_capture_slot, stream, pname, params );
    if ((status = UNIX_CALL( glVideoCaptureStreamParameterivNV, &args ))) WARN( "glVideoCaptureStreamParameterivNV returned %#lx\n", status );
}

static void WINAPI glViewportArrayv( GLuint first, GLsizei count, const GLfloat *v )
{
    struct glViewportArrayv_params args = { .teb = NtCurrentTeb(), .first = first, .count = count, .v = v };
    NTSTATUS status;
    TRACE( "first %d, count %d, v %p\n", first, count, v );
    if ((status = UNIX_CALL( glViewportArrayv, &args ))) WARN( "glViewportArrayv returned %#lx\n", status );
}

static void WINAPI glViewportIndexedf( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h )
{
    struct glViewportIndexedf_params args = { .teb = NtCurrentTeb(), .index = index, .x = x, .y = y, .w = w, .h = h };
    NTSTATUS status;
    TRACE( "index %d, x %f, y %f, w %f, h %f\n", index, x, y, w, h );
    if ((status = UNIX_CALL( glViewportIndexedf, &args ))) WARN( "glViewportIndexedf returned %#lx\n", status );
}

static void WINAPI glViewportIndexedfv( GLuint index, const GLfloat *v )
{
    struct glViewportIndexedfv_params args = { .teb = NtCurrentTeb(), .index = index, .v = v };
    NTSTATUS status;
    TRACE( "index %d, v %p\n", index, v );
    if ((status = UNIX_CALL( glViewportIndexedfv, &args ))) WARN( "glViewportIndexedfv returned %#lx\n", status );
}

static void WINAPI glViewportPositionWScaleNV( GLuint index, GLfloat xcoeff, GLfloat ycoeff )
{
    struct glViewportPositionWScaleNV_params args = { .teb = NtCurrentTeb(), .index = index, .xcoeff = xcoeff, .ycoeff = ycoeff };
    NTSTATUS status;
    TRACE( "index %d, xcoeff %f, ycoeff %f\n", index, xcoeff, ycoeff );
    if ((status = UNIX_CALL( glViewportPositionWScaleNV, &args ))) WARN( "glViewportPositionWScaleNV returned %#lx\n", status );
}

static void WINAPI glViewportSwizzleNV( GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew )
{
    struct glViewportSwizzleNV_params args = { .teb = NtCurrentTeb(), .index = index, .swizzlex = swizzlex, .swizzley = swizzley, .swizzlez = swizzlez, .swizzlew = swizzlew };
    NTSTATUS status;
    TRACE( "index %d, swizzlex %d, swizzley %d, swizzlez %d, swizzlew %d\n", index, swizzlex, swizzley, swizzlez, swizzlew );
    if ((status = UNIX_CALL( glViewportSwizzleNV, &args ))) WARN( "glViewportSwizzleNV returned %#lx\n", status );
}

static void WINAPI glWaitSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *srcLayouts )
{
    struct glWaitSemaphoreEXT_params args = { .teb = NtCurrentTeb(), .semaphore = semaphore, .numBufferBarriers = numBufferBarriers, .buffers = buffers, .numTextureBarriers = numTextureBarriers, .textures = textures, .srcLayouts = srcLayouts };
    NTSTATUS status;
    TRACE( "semaphore %d, numBufferBarriers %d, buffers %p, numTextureBarriers %d, textures %p, srcLayouts %p\n", semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts );
    if ((status = UNIX_CALL( glWaitSemaphoreEXT, &args ))) WARN( "glWaitSemaphoreEXT returned %#lx\n", status );
}

static void WINAPI glWaitSemaphoreui64NVX( GLuint waitGpu, GLsizei fenceObjectCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray )
{
    struct glWaitSemaphoreui64NVX_params args = { .teb = NtCurrentTeb(), .waitGpu = waitGpu, .fenceObjectCount = fenceObjectCount, .semaphoreArray = semaphoreArray, .fenceValueArray = fenceValueArray };
    NTSTATUS status;
    TRACE( "waitGpu %d, fenceObjectCount %d, semaphoreArray %p, fenceValueArray %p\n", waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray );
    if ((status = UNIX_CALL( glWaitSemaphoreui64NVX, &args ))) WARN( "glWaitSemaphoreui64NVX returned %#lx\n", status );
}

static void WINAPI glWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout )
{
    struct glWaitSync_params args = { .teb = NtCurrentTeb(), .sync = sync, .flags = flags, .timeout = timeout };
    NTSTATUS status;
    TRACE( "sync %p, flags %d, timeout %s\n", sync, flags, wine_dbgstr_longlong(timeout) );
    if ((status = UNIX_CALL( glWaitSync, &args ))) WARN( "glWaitSync returned %#lx\n", status );
}

static void WINAPI glWaitVkSemaphoreNV( GLuint64 vkSemaphore )
{
    struct glWaitVkSemaphoreNV_params args = { .teb = NtCurrentTeb(), .vkSemaphore = vkSemaphore };
    NTSTATUS status;
    TRACE( "vkSemaphore %s\n", wine_dbgstr_longlong(vkSemaphore) );
    if ((status = UNIX_CALL( glWaitVkSemaphoreNV, &args ))) WARN( "glWaitVkSemaphoreNV returned %#lx\n", status );
}

static void WINAPI glWeightPathsNV( GLuint resultPath, GLsizei numPaths, const GLuint *paths, const GLfloat *weights )
{
    struct glWeightPathsNV_params args = { .teb = NtCurrentTeb(), .resultPath = resultPath, .numPaths = numPaths, .paths = paths, .weights = weights };
    NTSTATUS status;
    TRACE( "resultPath %d, numPaths %d, paths %p, weights %p\n", resultPath, numPaths, paths, weights );
    if ((status = UNIX_CALL( glWeightPathsNV, &args ))) WARN( "glWeightPathsNV returned %#lx\n", status );
}

static void WINAPI glWeightPointerARB( GLint size, GLenum type, GLsizei stride, const void *pointer )
{
    struct glWeightPointerARB_params args = { .teb = NtCurrentTeb(), .size = size, .type = type, .stride = stride, .pointer = pointer };
    NTSTATUS status;
    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
    if ((status = UNIX_CALL( glWeightPointerARB, &args ))) WARN( "glWeightPointerARB returned %#lx\n", status );
}

static void WINAPI glWeightbvARB( GLint size, const GLbyte *weights )
{
    struct glWeightbvARB_params args = { .teb = NtCurrentTeb(), .size = size, .weights = weights };
    NTSTATUS status;
    TRACE( "size %d, weights %p\n", size, weights );
    if ((status = UNIX_CALL( glWeightbvARB, &args ))) WARN( "glWeightbvARB returned %#lx\n", status );
}

static void WINAPI glWeightdvARB( GLint size, const GLdouble *weights )
{
    struct glWeightdvARB_params args = { .teb = NtCurrentTeb(), .size = size, .weights = weights };
    NTSTATUS status;
    TRACE( "size %d, weights %p\n", size, weights );
    if ((status = UNIX_CALL( glWeightdvARB, &args ))) WARN( "glWeightdvARB returned %#lx\n", status );
}

static void WINAPI glWeightfvARB( GLint size, const GLfloat *weights )
{
    struct glWeightfvARB_params args = { .teb = NtCurrentTeb(), .size = size, .weights = weights };
    NTSTATUS status;
    TRACE( "size %d, weights %p\n", size, weights );
    if ((status = UNIX_CALL( glWeightfvARB, &args ))) WARN( "glWeightfvARB returned %#lx\n", status );
}

static void WINAPI glWeightivARB( GLint size, const GLint *weights )
{
    struct glWeightivARB_params args = { .teb = NtCurrentTeb(), .size = size, .weights = weights };
    NTSTATUS status;
    TRACE( "size %d, weights %p\n", size, weights );
    if ((status = UNIX_CALL( glWeightivARB, &args ))) WARN( "glWeightivARB returned %#lx\n", status );
}

static void WINAPI glWeightsvARB( GLint size, const GLshort *weights )
{
    struct glWeightsvARB_params args = { .teb = NtCurrentTeb(), .size = size, .weights = weights };
    NTSTATUS status;
    TRACE( "size %d, weights %p\n", size, weights );
    if ((status = UNIX_CALL( glWeightsvARB, &args ))) WARN( "glWeightsvARB returned %#lx\n", status );
}

static void WINAPI glWeightubvARB( GLint size, const GLubyte *weights )
{
    struct glWeightubvARB_params args = { .teb = NtCurrentTeb(), .size = size, .weights = weights };
    NTSTATUS status;
    TRACE( "size %d, weights %p\n", size, weights );
    if ((status = UNIX_CALL( glWeightubvARB, &args ))) WARN( "glWeightubvARB returned %#lx\n", status );
}

static void WINAPI glWeightuivARB( GLint size, const GLuint *weights )
{
    struct glWeightuivARB_params args = { .teb = NtCurrentTeb(), .size = size, .weights = weights };
    NTSTATUS status;
    TRACE( "size %d, weights %p\n", size, weights );
    if ((status = UNIX_CALL( glWeightuivARB, &args ))) WARN( "glWeightuivARB returned %#lx\n", status );
}

static void WINAPI glWeightusvARB( GLint size, const GLushort *weights )
{
    struct glWeightusvARB_params args = { .teb = NtCurrentTeb(), .size = size, .weights = weights };
    NTSTATUS status;
    TRACE( "size %d, weights %p\n", size, weights );
    if ((status = UNIX_CALL( glWeightusvARB, &args ))) WARN( "glWeightusvARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2d( GLdouble x, GLdouble y )
{
    struct glWindowPos2d_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2d, &args ))) WARN( "glWindowPos2d returned %#lx\n", status );
}

static void WINAPI glWindowPos2dARB( GLdouble x, GLdouble y )
{
    struct glWindowPos2dARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2dARB, &args ))) WARN( "glWindowPos2dARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2dMESA( GLdouble x, GLdouble y )
{
    struct glWindowPos2dMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2dMESA, &args ))) WARN( "glWindowPos2dMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos2dv( const GLdouble *v )
{
    struct glWindowPos2dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2dv, &args ))) WARN( "glWindowPos2dv returned %#lx\n", status );
}

static void WINAPI glWindowPos2dvARB( const GLdouble *v )
{
    struct glWindowPos2dvARB_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2dvARB, &args ))) WARN( "glWindowPos2dvARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2dvMESA( const GLdouble *v )
{
    struct glWindowPos2dvMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2dvMESA, &args ))) WARN( "glWindowPos2dvMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos2f( GLfloat x, GLfloat y )
{
    struct glWindowPos2f_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2f, &args ))) WARN( "glWindowPos2f returned %#lx\n", status );
}

static void WINAPI glWindowPos2fARB( GLfloat x, GLfloat y )
{
    struct glWindowPos2fARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2fARB, &args ))) WARN( "glWindowPos2fARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2fMESA( GLfloat x, GLfloat y )
{
    struct glWindowPos2fMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %f, y %f\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2fMESA, &args ))) WARN( "glWindowPos2fMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos2fv( const GLfloat *v )
{
    struct glWindowPos2fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2fv, &args ))) WARN( "glWindowPos2fv returned %#lx\n", status );
}

static void WINAPI glWindowPos2fvARB( const GLfloat *v )
{
    struct glWindowPos2fvARB_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2fvARB, &args ))) WARN( "glWindowPos2fvARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2fvMESA( const GLfloat *v )
{
    struct glWindowPos2fvMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2fvMESA, &args ))) WARN( "glWindowPos2fvMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos2i( GLint x, GLint y )
{
    struct glWindowPos2i_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2i, &args ))) WARN( "glWindowPos2i returned %#lx\n", status );
}

static void WINAPI glWindowPos2iARB( GLint x, GLint y )
{
    struct glWindowPos2iARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2iARB, &args ))) WARN( "glWindowPos2iARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2iMESA( GLint x, GLint y )
{
    struct glWindowPos2iMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2iMESA, &args ))) WARN( "glWindowPos2iMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos2iv( const GLint *v )
{
    struct glWindowPos2iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2iv, &args ))) WARN( "glWindowPos2iv returned %#lx\n", status );
}

static void WINAPI glWindowPos2ivARB( const GLint *v )
{
    struct glWindowPos2ivARB_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2ivARB, &args ))) WARN( "glWindowPos2ivARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2ivMESA( const GLint *v )
{
    struct glWindowPos2ivMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2ivMESA, &args ))) WARN( "glWindowPos2ivMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos2s( GLshort x, GLshort y )
{
    struct glWindowPos2s_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2s, &args ))) WARN( "glWindowPos2s returned %#lx\n", status );
}

static void WINAPI glWindowPos2sARB( GLshort x, GLshort y )
{
    struct glWindowPos2sARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2sARB, &args ))) WARN( "glWindowPos2sARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2sMESA( GLshort x, GLshort y )
{
    struct glWindowPos2sMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y };
    NTSTATUS status;
    TRACE( "x %d, y %d\n", x, y );
    if ((status = UNIX_CALL( glWindowPos2sMESA, &args ))) WARN( "glWindowPos2sMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos2sv( const GLshort *v )
{
    struct glWindowPos2sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2sv, &args ))) WARN( "glWindowPos2sv returned %#lx\n", status );
}

static void WINAPI glWindowPos2svARB( const GLshort *v )
{
    struct glWindowPos2svARB_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2svARB, &args ))) WARN( "glWindowPos2svARB returned %#lx\n", status );
}

static void WINAPI glWindowPos2svMESA( const GLshort *v )
{
    struct glWindowPos2svMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos2svMESA, &args ))) WARN( "glWindowPos2svMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos3d( GLdouble x, GLdouble y, GLdouble z )
{
    struct glWindowPos3d_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3d, &args ))) WARN( "glWindowPos3d returned %#lx\n", status );
}

static void WINAPI glWindowPos3dARB( GLdouble x, GLdouble y, GLdouble z )
{
    struct glWindowPos3dARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3dARB, &args ))) WARN( "glWindowPos3dARB returned %#lx\n", status );
}

static void WINAPI glWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z )
{
    struct glWindowPos3dMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3dMESA, &args ))) WARN( "glWindowPos3dMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos3dv( const GLdouble *v )
{
    struct glWindowPos3dv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3dv, &args ))) WARN( "glWindowPos3dv returned %#lx\n", status );
}

static void WINAPI glWindowPos3dvARB( const GLdouble *v )
{
    struct glWindowPos3dvARB_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3dvARB, &args ))) WARN( "glWindowPos3dvARB returned %#lx\n", status );
}

static void WINAPI glWindowPos3dvMESA( const GLdouble *v )
{
    struct glWindowPos3dvMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3dvMESA, &args ))) WARN( "glWindowPos3dvMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos3f( GLfloat x, GLfloat y, GLfloat z )
{
    struct glWindowPos3f_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3f, &args ))) WARN( "glWindowPos3f returned %#lx\n", status );
}

static void WINAPI glWindowPos3fARB( GLfloat x, GLfloat y, GLfloat z )
{
    struct glWindowPos3fARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3fARB, &args ))) WARN( "glWindowPos3fARB returned %#lx\n", status );
}

static void WINAPI glWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z )
{
    struct glWindowPos3fMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3fMESA, &args ))) WARN( "glWindowPos3fMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos3fv( const GLfloat *v )
{
    struct glWindowPos3fv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3fv, &args ))) WARN( "glWindowPos3fv returned %#lx\n", status );
}

static void WINAPI glWindowPos3fvARB( const GLfloat *v )
{
    struct glWindowPos3fvARB_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3fvARB, &args ))) WARN( "glWindowPos3fvARB returned %#lx\n", status );
}

static void WINAPI glWindowPos3fvMESA( const GLfloat *v )
{
    struct glWindowPos3fvMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3fvMESA, &args ))) WARN( "glWindowPos3fvMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos3i( GLint x, GLint y, GLint z )
{
    struct glWindowPos3i_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3i, &args ))) WARN( "glWindowPos3i returned %#lx\n", status );
}

static void WINAPI glWindowPos3iARB( GLint x, GLint y, GLint z )
{
    struct glWindowPos3iARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3iARB, &args ))) WARN( "glWindowPos3iARB returned %#lx\n", status );
}

static void WINAPI glWindowPos3iMESA( GLint x, GLint y, GLint z )
{
    struct glWindowPos3iMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3iMESA, &args ))) WARN( "glWindowPos3iMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos3iv( const GLint *v )
{
    struct glWindowPos3iv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3iv, &args ))) WARN( "glWindowPos3iv returned %#lx\n", status );
}

static void WINAPI glWindowPos3ivARB( const GLint *v )
{
    struct glWindowPos3ivARB_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3ivARB, &args ))) WARN( "glWindowPos3ivARB returned %#lx\n", status );
}

static void WINAPI glWindowPos3ivMESA( const GLint *v )
{
    struct glWindowPos3ivMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3ivMESA, &args ))) WARN( "glWindowPos3ivMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos3s( GLshort x, GLshort y, GLshort z )
{
    struct glWindowPos3s_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3s, &args ))) WARN( "glWindowPos3s returned %#lx\n", status );
}

static void WINAPI glWindowPos3sARB( GLshort x, GLshort y, GLshort z )
{
    struct glWindowPos3sARB_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3sARB, &args ))) WARN( "glWindowPos3sARB returned %#lx\n", status );
}

static void WINAPI glWindowPos3sMESA( GLshort x, GLshort y, GLshort z )
{
    struct glWindowPos3sMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d\n", x, y, z );
    if ((status = UNIX_CALL( glWindowPos3sMESA, &args ))) WARN( "glWindowPos3sMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos3sv( const GLshort *v )
{
    struct glWindowPos3sv_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3sv, &args ))) WARN( "glWindowPos3sv returned %#lx\n", status );
}

static void WINAPI glWindowPos3svARB( const GLshort *v )
{
    struct glWindowPos3svARB_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3svARB, &args ))) WARN( "glWindowPos3svARB returned %#lx\n", status );
}

static void WINAPI glWindowPos3svMESA( const GLshort *v )
{
    struct glWindowPos3svMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos3svMESA, &args ))) WARN( "glWindowPos3svMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
    struct glWindowPos4dMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
    if ((status = UNIX_CALL( glWindowPos4dMESA, &args ))) WARN( "glWindowPos4dMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos4dvMESA( const GLdouble *v )
{
    struct glWindowPos4dvMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos4dvMESA, &args ))) WARN( "glWindowPos4dvMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
    struct glWindowPos4fMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
    if ((status = UNIX_CALL( glWindowPos4fMESA, &args ))) WARN( "glWindowPos4fMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos4fvMESA( const GLfloat *v )
{
    struct glWindowPos4fvMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos4fvMESA, &args ))) WARN( "glWindowPos4fvMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w )
{
    struct glWindowPos4iMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glWindowPos4iMESA, &args ))) WARN( "glWindowPos4iMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos4ivMESA( const GLint *v )
{
    struct glWindowPos4ivMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos4ivMESA, &args ))) WARN( "glWindowPos4ivMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w )
{
    struct glWindowPos4sMESA_params args = { .teb = NtCurrentTeb(), .x = x, .y = y, .z = z, .w = w };
    NTSTATUS status;
    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
    if ((status = UNIX_CALL( glWindowPos4sMESA, &args ))) WARN( "glWindowPos4sMESA returned %#lx\n", status );
}

static void WINAPI glWindowPos4svMESA( const GLshort *v )
{
    struct glWindowPos4svMESA_params args = { .teb = NtCurrentTeb(), .v = v };
    NTSTATUS status;
    TRACE( "v %p\n", v );
    if ((status = UNIX_CALL( glWindowPos4svMESA, &args ))) WARN( "glWindowPos4svMESA returned %#lx\n", status );
}

static void WINAPI glWindowRectanglesEXT( GLenum mode, GLsizei count, const GLint *box )
{
    struct glWindowRectanglesEXT_params args = { .teb = NtCurrentTeb(), .mode = mode, .count = count, .box = box };
    NTSTATUS status;
    TRACE( "mode %d, count %d, box %p\n", mode, count, box );
    if ((status = UNIX_CALL( glWindowRectanglesEXT, &args ))) WARN( "glWindowRectanglesEXT returned %#lx\n", status );
}

static void WINAPI glWriteMaskEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW )
{
    struct glWriteMaskEXT_params args = { .teb = NtCurrentTeb(), .res = res, .in = in, .outX = outX, .outY = outY, .outZ = outZ, .outW = outW };
    NTSTATUS status;
    TRACE( "res %d, in %d, outX %d, outY %d, outZ %d, outW %d\n", res, in, outX, outY, outZ, outW );
    if ((status = UNIX_CALL( glWriteMaskEXT, &args ))) WARN( "glWriteMaskEXT returned %#lx\n", status );
}

static void * WINAPI wglAllocateMemoryNV( GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority )
{
    struct wglAllocateMemoryNV_params args = { .teb = NtCurrentTeb(), .size = size, .readfreq = readfreq, .writefreq = writefreq, .priority = priority };
    NTSTATUS status;
    TRACE( "size %d, readfreq %f, writefreq %f, priority %f\n", size, readfreq, writefreq, priority );
    if ((status = UNIX_CALL( wglAllocateMemoryNV, &args ))) WARN( "wglAllocateMemoryNV returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglBindTexImageARB( HPBUFFERARB hPbuffer, int iBuffer )
{
    struct wglBindTexImageARB_params args = { .teb = NtCurrentTeb(), .hPbuffer = hPbuffer, .iBuffer = iBuffer };
    NTSTATUS status;
    TRACE( "hPbuffer %p, iBuffer %d\n", hPbuffer, iBuffer );
    if ((status = UNIX_CALL( wglBindTexImageARB, &args ))) WARN( "wglBindTexImageARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglChoosePixelFormatARB( HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats )
{
    struct wglChoosePixelFormatARB_params args = { .teb = NtCurrentTeb(), .hdc = hdc, .piAttribIList = piAttribIList, .pfAttribFList = pfAttribFList, .nMaxFormats = nMaxFormats, .piFormats = piFormats, .nNumFormats = nNumFormats };
    NTSTATUS status;
    TRACE( "hdc %p, piAttribIList %p, pfAttribFList %p, nMaxFormats %u, piFormats %p, nNumFormats %p\n", hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats );
    if ((status = UNIX_CALL( wglChoosePixelFormatARB, &args ))) WARN( "wglChoosePixelFormatARB returned %#lx\n", status );
    return args.ret;
}

static HGLRC WINAPI wglCreateContextAttribsARB( HDC hDC, HGLRC hShareContext, const int *attribList )
{
    struct wglCreateContextAttribsARB_params args = { .teb = NtCurrentTeb(), .hDC = hDC, .hShareContext = hShareContext, .attribList = attribList };
    NTSTATUS status;
    TRACE( "hDC %p, hShareContext %p, attribList %p\n", hDC, hShareContext, attribList );
    if ((status = UNIX_CALL( wglCreateContextAttribsARB, &args ))) WARN( "wglCreateContextAttribsARB returned %#lx\n", status );
    return args.ret;
}

static HPBUFFERARB WINAPI wglCreatePbufferARB( HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList )
{
    struct wglCreatePbufferARB_params args = { .teb = NtCurrentTeb(), .hDC = hDC, .iPixelFormat = iPixelFormat, .iWidth = iWidth, .iHeight = iHeight, .piAttribList = piAttribList };
    NTSTATUS status;
    TRACE( "hDC %p, iPixelFormat %d, iWidth %d, iHeight %d, piAttribList %p\n", hDC, iPixelFormat, iWidth, iHeight, piAttribList );
    if ((status = UNIX_CALL( wglCreatePbufferARB, &args ))) WARN( "wglCreatePbufferARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglDestroyPbufferARB( HPBUFFERARB hPbuffer )
{
    struct wglDestroyPbufferARB_params args = { .teb = NtCurrentTeb(), .hPbuffer = hPbuffer };
    NTSTATUS status;
    TRACE( "hPbuffer %p\n", hPbuffer );
    if ((status = UNIX_CALL( wglDestroyPbufferARB, &args ))) WARN( "wglDestroyPbufferARB returned %#lx\n", status );
    return args.ret;
}

static void WINAPI wglFreeMemoryNV( void *pointer )
{
    struct wglFreeMemoryNV_params args = { .teb = NtCurrentTeb(), .pointer = pointer };
    NTSTATUS status;
    TRACE( "pointer %p\n", pointer );
    if ((status = UNIX_CALL( wglFreeMemoryNV, &args ))) WARN( "wglFreeMemoryNV returned %#lx\n", status );
}

static HDC WINAPI wglGetPbufferDCARB( HPBUFFERARB hPbuffer )
{
    struct wglGetPbufferDCARB_params args = { .teb = NtCurrentTeb(), .hPbuffer = hPbuffer };
    NTSTATUS status;
    TRACE( "hPbuffer %p\n", hPbuffer );
    if ((status = UNIX_CALL( wglGetPbufferDCARB, &args ))) WARN( "wglGetPbufferDCARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglGetPixelFormatAttribfvARB( HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues )
{
    struct wglGetPixelFormatAttribfvARB_params args = { .teb = NtCurrentTeb(), .hdc = hdc, .iPixelFormat = iPixelFormat, .iLayerPlane = iLayerPlane, .nAttributes = nAttributes, .piAttributes = piAttributes, .pfValues = pfValues };
    NTSTATUS status;
    TRACE( "hdc %p, iPixelFormat %d, iLayerPlane %d, nAttributes %u, piAttributes %p, pfValues %p\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues );
    if ((status = UNIX_CALL( wglGetPixelFormatAttribfvARB, &args ))) WARN( "wglGetPixelFormatAttribfvARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglGetPixelFormatAttribivARB( HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues )
{
    struct wglGetPixelFormatAttribivARB_params args = { .teb = NtCurrentTeb(), .hdc = hdc, .iPixelFormat = iPixelFormat, .iLayerPlane = iLayerPlane, .nAttributes = nAttributes, .piAttributes = piAttributes, .piValues = piValues };
    NTSTATUS status;
    TRACE( "hdc %p, iPixelFormat %d, iLayerPlane %d, nAttributes %u, piAttributes %p, piValues %p\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues );
    if ((status = UNIX_CALL( wglGetPixelFormatAttribivARB, &args ))) WARN( "wglGetPixelFormatAttribivARB returned %#lx\n", status );
    return args.ret;
}

static int WINAPI wglGetSwapIntervalEXT(void)
{
    struct wglGetSwapIntervalEXT_params args = { .teb = NtCurrentTeb() };
    NTSTATUS status;
    TRACE( "\n" );
    if ((status = UNIX_CALL( wglGetSwapIntervalEXT, &args ))) WARN( "wglGetSwapIntervalEXT returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglMakeContextCurrentARB( HDC hDrawDC, HDC hReadDC, HGLRC hglrc )
{
    struct wglMakeContextCurrentARB_params args = { .teb = NtCurrentTeb(), .hDrawDC = hDrawDC, .hReadDC = hReadDC, .hglrc = hglrc };
    NTSTATUS status;
    TRACE( "hDrawDC %p, hReadDC %p, hglrc %p\n", hDrawDC, hReadDC, hglrc );
    if ((status = UNIX_CALL( wglMakeContextCurrentARB, &args ))) WARN( "wglMakeContextCurrentARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglQueryCurrentRendererIntegerWINE( GLenum attribute, GLuint *value )
{
    struct wglQueryCurrentRendererIntegerWINE_params args = { .teb = NtCurrentTeb(), .attribute = attribute, .value = value };
    NTSTATUS status;
    TRACE( "attribute %d, value %p\n", attribute, value );
    if ((status = UNIX_CALL( wglQueryCurrentRendererIntegerWINE, &args ))) WARN( "wglQueryCurrentRendererIntegerWINE returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglQueryPbufferARB( HPBUFFERARB hPbuffer, int iAttribute, int *piValue )
{
    struct wglQueryPbufferARB_params args = { .teb = NtCurrentTeb(), .hPbuffer = hPbuffer, .iAttribute = iAttribute, .piValue = piValue };
    NTSTATUS status;
    TRACE( "hPbuffer %p, iAttribute %d, piValue %p\n", hPbuffer, iAttribute, piValue );
    if ((status = UNIX_CALL( wglQueryPbufferARB, &args ))) WARN( "wglQueryPbufferARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglQueryRendererIntegerWINE( HDC dc, GLint renderer, GLenum attribute, GLuint *value )
{
    struct wglQueryRendererIntegerWINE_params args = { .teb = NtCurrentTeb(), .dc = dc, .renderer = renderer, .attribute = attribute, .value = value };
    NTSTATUS status;
    TRACE( "dc %p, renderer %d, attribute %d, value %p\n", dc, renderer, attribute, value );
    if ((status = UNIX_CALL( wglQueryRendererIntegerWINE, &args ))) WARN( "wglQueryRendererIntegerWINE returned %#lx\n", status );
    return args.ret;
}

static int WINAPI wglReleasePbufferDCARB( HPBUFFERARB hPbuffer, HDC hDC )
{
    struct wglReleasePbufferDCARB_params args = { .teb = NtCurrentTeb(), .hPbuffer = hPbuffer, .hDC = hDC };
    NTSTATUS status;
    TRACE( "hPbuffer %p, hDC %p\n", hPbuffer, hDC );
    if ((status = UNIX_CALL( wglReleasePbufferDCARB, &args ))) WARN( "wglReleasePbufferDCARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglReleaseTexImageARB( HPBUFFERARB hPbuffer, int iBuffer )
{
    struct wglReleaseTexImageARB_params args = { .teb = NtCurrentTeb(), .hPbuffer = hPbuffer, .iBuffer = iBuffer };
    NTSTATUS status;
    TRACE( "hPbuffer %p, iBuffer %d\n", hPbuffer, iBuffer );
    if ((status = UNIX_CALL( wglReleaseTexImageARB, &args ))) WARN( "wglReleaseTexImageARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglSetPbufferAttribARB( HPBUFFERARB hPbuffer, const int *piAttribList )
{
    struct wglSetPbufferAttribARB_params args = { .teb = NtCurrentTeb(), .hPbuffer = hPbuffer, .piAttribList = piAttribList };
    NTSTATUS status;
    TRACE( "hPbuffer %p, piAttribList %p\n", hPbuffer, piAttribList );
    if ((status = UNIX_CALL( wglSetPbufferAttribARB, &args ))) WARN( "wglSetPbufferAttribARB returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglSetPixelFormatWINE( HDC hdc, int format )
{
    struct wglSetPixelFormatWINE_params args = { .teb = NtCurrentTeb(), .hdc = hdc, .format = format };
    NTSTATUS status;
    TRACE( "hdc %p, format %d\n", hdc, format );
    if ((status = UNIX_CALL( wglSetPixelFormatWINE, &args ))) WARN( "wglSetPixelFormatWINE returned %#lx\n", status );
    return args.ret;
}

static BOOL WINAPI wglSwapIntervalEXT( int interval )
{
    struct wglSwapIntervalEXT_params args = { .teb = NtCurrentTeb(), .interval = interval };
    NTSTATUS status;
    TRACE( "interval %d\n", interval );
    if ((status = UNIX_CALL( wglSwapIntervalEXT, &args ))) WARN( "wglSwapIntervalEXT returned %#lx\n", status );
    return args.ret;
}

extern const GLubyte * WINAPI glGetStringi( GLenum name, GLuint index ) DECLSPEC_HIDDEN;
extern void * WINAPI glMapBuffer( GLenum target, GLenum access ) DECLSPEC_HIDDEN;
extern void * WINAPI glMapBufferARB( GLenum target, GLenum access ) DECLSPEC_HIDDEN;
extern void * WINAPI glMapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access ) DECLSPEC_HIDDEN;
extern void * WINAPI glMapNamedBuffer( GLuint buffer, GLenum access ) DECLSPEC_HIDDEN;
extern void * WINAPI glMapNamedBufferEXT( GLuint buffer, GLenum access ) DECLSPEC_HIDDEN;
extern void * WINAPI glMapNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access ) DECLSPEC_HIDDEN;
extern void * WINAPI glMapNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access ) DECLSPEC_HIDDEN;
extern GLboolean WINAPI glUnmapBuffer( GLenum target ) DECLSPEC_HIDDEN;
extern GLboolean WINAPI glUnmapBufferARB( GLenum target ) DECLSPEC_HIDDEN;
extern GLboolean WINAPI glUnmapNamedBuffer( GLuint buffer ) DECLSPEC_HIDDEN;
extern GLboolean WINAPI glUnmapNamedBufferEXT( GLuint buffer ) DECLSPEC_HIDDEN;
extern HDC WINAPI wglGetCurrentReadDCARB(void) DECLSPEC_HIDDEN;
extern const char * WINAPI wglGetExtensionsStringARB( HDC hdc ) DECLSPEC_HIDDEN;
extern const char * WINAPI wglGetExtensionsStringEXT(void) DECLSPEC_HIDDEN;
extern const GLchar * WINAPI wglQueryCurrentRendererStringWINE( GLenum attribute ) DECLSPEC_HIDDEN;
extern const GLchar * WINAPI wglQueryRendererStringWINE( HDC dc, GLint renderer, GLenum attribute ) DECLSPEC_HIDDEN;
const void *extension_procs[] =
{
    glAccumxOES,
    glAcquireKeyedMutexWin32EXT,
    glActiveProgramEXT,
    glActiveShaderProgram,
    glActiveStencilFaceEXT,
    glActiveTexture,
    glActiveTextureARB,
    glActiveVaryingNV,
    glAlphaFragmentOp1ATI,
    glAlphaFragmentOp2ATI,
    glAlphaFragmentOp3ATI,
    glAlphaFuncxOES,
    glAlphaToCoverageDitherControlNV,
    glApplyFramebufferAttachmentCMAAINTEL,
    glApplyTextureEXT,
    glAreProgramsResidentNV,
    glAreTexturesResidentEXT,
    glArrayElementEXT,
    glArrayObjectATI,
    glAsyncCopyBufferSubDataNVX,
    glAsyncCopyImageSubDataNVX,
    glAsyncMarkerSGIX,
    glAttachObjectARB,
    glAttachShader,
    glBeginConditionalRender,
    glBeginConditionalRenderNV,
    glBeginConditionalRenderNVX,
    glBeginFragmentShaderATI,
    glBeginOcclusionQueryNV,
    glBeginPerfMonitorAMD,
    glBeginPerfQueryINTEL,
    glBeginQuery,
    glBeginQueryARB,
    glBeginQueryIndexed,
    glBeginTransformFeedback,
    glBeginTransformFeedbackEXT,
    glBeginTransformFeedbackNV,
    glBeginVertexShaderEXT,
    glBeginVideoCaptureNV,
    glBindAttribLocation,
    glBindAttribLocationARB,
    glBindBuffer,
    glBindBufferARB,
    glBindBufferBase,
    glBindBufferBaseEXT,
    glBindBufferBaseNV,
    glBindBufferOffsetEXT,
    glBindBufferOffsetNV,
    glBindBufferRange,
    glBindBufferRangeEXT,
    glBindBufferRangeNV,
    glBindBuffersBase,
    glBindBuffersRange,
    glBindFragDataLocation,
    glBindFragDataLocationEXT,
    glBindFragDataLocationIndexed,
    glBindFragmentShaderATI,
    glBindFramebuffer,
    glBindFramebufferEXT,
    glBindImageTexture,
    glBindImageTextureEXT,
    glBindImageTextures,
    glBindLightParameterEXT,
    glBindMaterialParameterEXT,
    glBindMultiTextureEXT,
    glBindParameterEXT,
    glBindProgramARB,
    glBindProgramNV,
    glBindProgramPipeline,
    glBindRenderbuffer,
    glBindRenderbufferEXT,
    glBindSampler,
    glBindSamplers,
    glBindShadingRateImageNV,
    glBindTexGenParameterEXT,
    glBindTextureEXT,
    glBindTextureUnit,
    glBindTextureUnitParameterEXT,
    glBindTextures,
    glBindTransformFeedback,
    glBindTransformFeedbackNV,
    glBindVertexArray,
    glBindVertexArrayAPPLE,
    glBindVertexBuffer,
    glBindVertexBuffers,
    glBindVertexShaderEXT,
    glBindVideoCaptureStreamBufferNV,
    glBindVideoCaptureStreamTextureNV,
    glBinormal3bEXT,
    glBinormal3bvEXT,
    glBinormal3dEXT,
    glBinormal3dvEXT,
    glBinormal3fEXT,
    glBinormal3fvEXT,
    glBinormal3iEXT,
    glBinormal3ivEXT,
    glBinormal3sEXT,
    glBinormal3svEXT,
    glBinormalPointerEXT,
    glBitmapxOES,
    glBlendBarrierKHR,
    glBlendBarrierNV,
    glBlendColor,
    glBlendColorEXT,
    glBlendColorxOES,
    glBlendEquation,
    glBlendEquationEXT,
    glBlendEquationIndexedAMD,
    glBlendEquationSeparate,
    glBlendEquationSeparateEXT,
    glBlendEquationSeparateIndexedAMD,
    glBlendEquationSeparatei,
    glBlendEquationSeparateiARB,
    glBlendEquationi,
    glBlendEquationiARB,
    glBlendFuncIndexedAMD,
    glBlendFuncSeparate,
    glBlendFuncSeparateEXT,
    glBlendFuncSeparateINGR,
    glBlendFuncSeparateIndexedAMD,
    glBlendFuncSeparatei,
    glBlendFuncSeparateiARB,
    glBlendFunci,
    glBlendFunciARB,
    glBlendParameteriNV,
    glBlitFramebuffer,
    glBlitFramebufferEXT,
    glBlitNamedFramebuffer,
    glBufferAddressRangeNV,
    glBufferAttachMemoryNV,
    glBufferData,
    glBufferDataARB,
    glBufferPageCommitmentARB,
    glBufferParameteriAPPLE,
    glBufferRegionEnabled,
    glBufferStorage,
    glBufferStorageExternalEXT,
    glBufferStorageMemEXT,
    glBufferSubData,
    glBufferSubDataARB,
    glCallCommandListNV,
    glCheckFramebufferStatus,
    glCheckFramebufferStatusEXT,
    glCheckNamedFramebufferStatus,
    glCheckNamedFramebufferStatusEXT,
    glClampColor,
    glClampColorARB,
    glClearAccumxOES,
    glClearBufferData,
    glClearBufferSubData,
    glClearBufferfi,
    glClearBufferfv,
    glClearBufferiv,
    glClearBufferuiv,
    glClearColorIiEXT,
    glClearColorIuiEXT,
    glClearColorxOES,
    glClearDepthdNV,
    glClearDepthf,
    glClearDepthfOES,
    glClearDepthxOES,
    glClearNamedBufferData,
    glClearNamedBufferDataEXT,
    glClearNamedBufferSubData,
    glClearNamedBufferSubDataEXT,
    glClearNamedFramebufferfi,
    glClearNamedFramebufferfv,
    glClearNamedFramebufferiv,
    glClearNamedFramebufferuiv,
    glClearTexImage,
    glClearTexSubImage,
    glClientActiveTexture,
    glClientActiveTextureARB,
    glClientActiveVertexStreamATI,
    glClientAttribDefaultEXT,
    glClientWaitSemaphoreui64NVX,
    glClientWaitSync,
    glClipControl,
    glClipPlanefOES,
    glClipPlanexOES,
    glColor3fVertex3fSUN,
    glColor3fVertex3fvSUN,
    glColor3hNV,
    glColor3hvNV,
    glColor3xOES,
    glColor3xvOES,
    glColor4fNormal3fVertex3fSUN,
    glColor4fNormal3fVertex3fvSUN,
    glColor4hNV,
    glColor4hvNV,
    glColor4ubVertex2fSUN,
    glColor4ubVertex2fvSUN,
    glColor4ubVertex3fSUN,
    glColor4ubVertex3fvSUN,
    glColor4xOES,
    glColor4xvOES,
    glColorFormatNV,
    glColorFragmentOp1ATI,
    glColorFragmentOp2ATI,
    glColorFragmentOp3ATI,
    glColorMaskIndexedEXT,
    glColorMaski,
    glColorP3ui,
    glColorP3uiv,
    glColorP4ui,
    glColorP4uiv,
    glColorPointerEXT,
    glColorPointerListIBM,
    glColorPointervINTEL,
    glColorSubTable,
    glColorSubTableEXT,
    glColorTable,
    glColorTableEXT,
    glColorTableParameterfv,
    glColorTableParameterfvSGI,
    glColorTableParameteriv,
    glColorTableParameterivSGI,
    glColorTableSGI,
    glCombinerInputNV,
    glCombinerOutputNV,
    glCombinerParameterfNV,
    glCombinerParameterfvNV,
    glCombinerParameteriNV,
    glCombinerParameterivNV,
    glCombinerStageParameterfvNV,
    glCommandListSegmentsNV,
    glCompileCommandListNV,
    glCompileShader,
    glCompileShaderARB,
    glCompileShaderIncludeARB,
    glCompressedMultiTexImage1DEXT,
    glCompressedMultiTexImage2DEXT,
    glCompressedMultiTexImage3DEXT,
    glCompressedMultiTexSubImage1DEXT,
    glCompressedMultiTexSubImage2DEXT,
    glCompressedMultiTexSubImage3DEXT,
    glCompressedTexImage1D,
    glCompressedTexImage1DARB,
    glCompressedTexImage2D,
    glCompressedTexImage2DARB,
    glCompressedTexImage3D,
    glCompressedTexImage3DARB,
    glCompressedTexSubImage1D,
    glCompressedTexSubImage1DARB,
    glCompressedTexSubImage2D,
    glCompressedTexSubImage2DARB,
    glCompressedTexSubImage3D,
    glCompressedTexSubImage3DARB,
    glCompressedTextureImage1DEXT,
    glCompressedTextureImage2DEXT,
    glCompressedTextureImage3DEXT,
    glCompressedTextureSubImage1D,
    glCompressedTextureSubImage1DEXT,
    glCompressedTextureSubImage2D,
    glCompressedTextureSubImage2DEXT,
    glCompressedTextureSubImage3D,
    glCompressedTextureSubImage3DEXT,
    glConservativeRasterParameterfNV,
    glConservativeRasterParameteriNV,
    glConvolutionFilter1D,
    glConvolutionFilter1DEXT,
    glConvolutionFilter2D,
    glConvolutionFilter2DEXT,
    glConvolutionParameterf,
    glConvolutionParameterfEXT,
    glConvolutionParameterfv,
    glConvolutionParameterfvEXT,
    glConvolutionParameteri,
    glConvolutionParameteriEXT,
    glConvolutionParameteriv,
    glConvolutionParameterivEXT,
    glConvolutionParameterxOES,
    glConvolutionParameterxvOES,
    glCopyBufferSubData,
    glCopyColorSubTable,
    glCopyColorSubTableEXT,
    glCopyColorTable,
    glCopyColorTableSGI,
    glCopyConvolutionFilter1D,
    glCopyConvolutionFilter1DEXT,
    glCopyConvolutionFilter2D,
    glCopyConvolutionFilter2DEXT,
    glCopyImageSubData,
    glCopyImageSubDataNV,
    glCopyMultiTexImage1DEXT,
    glCopyMultiTexImage2DEXT,
    glCopyMultiTexSubImage1DEXT,
    glCopyMultiTexSubImage2DEXT,
    glCopyMultiTexSubImage3DEXT,
    glCopyNamedBufferSubData,
    glCopyPathNV,
    glCopyTexImage1DEXT,
    glCopyTexImage2DEXT,
    glCopyTexSubImage1DEXT,
    glCopyTexSubImage2DEXT,
    glCopyTexSubImage3D,
    glCopyTexSubImage3DEXT,
    glCopyTextureImage1DEXT,
    glCopyTextureImage2DEXT,
    glCopyTextureSubImage1D,
    glCopyTextureSubImage1DEXT,
    glCopyTextureSubImage2D,
    glCopyTextureSubImage2DEXT,
    glCopyTextureSubImage3D,
    glCopyTextureSubImage3DEXT,
    glCoverFillPathInstancedNV,
    glCoverFillPathNV,
    glCoverStrokePathInstancedNV,
    glCoverStrokePathNV,
    glCoverageModulationNV,
    glCoverageModulationTableNV,
    glCreateBuffers,
    glCreateCommandListsNV,
    glCreateFramebuffers,
    glCreateMemoryObjectsEXT,
    glCreatePerfQueryINTEL,
    glCreateProgram,
    glCreateProgramObjectARB,
    glCreateProgramPipelines,
    glCreateProgressFenceNVX,
    glCreateQueries,
    glCreateRenderbuffers,
    glCreateSamplers,
    glCreateShader,
    glCreateShaderObjectARB,
    glCreateShaderProgramEXT,
    glCreateShaderProgramv,
    glCreateStatesNV,
    glCreateSyncFromCLeventARB,
    glCreateTextures,
    glCreateTransformFeedbacks,
    glCreateVertexArrays,
    glCullParameterdvEXT,
    glCullParameterfvEXT,
    glCurrentPaletteMatrixARB,
    glDebugMessageCallback,
    glDebugMessageCallbackAMD,
    glDebugMessageCallbackARB,
    glDebugMessageControl,
    glDebugMessageControlARB,
    glDebugMessageEnableAMD,
    glDebugMessageInsert,
    glDebugMessageInsertAMD,
    glDebugMessageInsertARB,
    glDeformSGIX,
    glDeformationMap3dSGIX,
    glDeformationMap3fSGIX,
    glDeleteAsyncMarkersSGIX,
    glDeleteBufferRegion,
    glDeleteBuffers,
    glDeleteBuffersARB,
    glDeleteCommandListsNV,
    glDeleteFencesAPPLE,
    glDeleteFencesNV,
    glDeleteFragmentShaderATI,
    glDeleteFramebuffers,
    glDeleteFramebuffersEXT,
    glDeleteMemoryObjectsEXT,
    glDeleteNamedStringARB,
    glDeleteNamesAMD,
    glDeleteObjectARB,
    glDeleteObjectBufferATI,
    glDeleteOcclusionQueriesNV,
    glDeletePathsNV,
    glDeletePerfMonitorsAMD,
    glDeletePerfQueryINTEL,
    glDeleteProgram,
    glDeleteProgramPipelines,
    glDeleteProgramsARB,
    glDeleteProgramsNV,
    glDeleteQueries,
    glDeleteQueriesARB,
    glDeleteQueryResourceTagNV,
    glDeleteRenderbuffers,
    glDeleteRenderbuffersEXT,
    glDeleteSamplers,
    glDeleteSemaphoresEXT,
    glDeleteShader,
    glDeleteStatesNV,
    glDeleteSync,
    glDeleteTexturesEXT,
    glDeleteTransformFeedbacks,
    glDeleteTransformFeedbacksNV,
    glDeleteVertexArrays,
    glDeleteVertexArraysAPPLE,
    glDeleteVertexShaderEXT,
    glDepthBoundsEXT,
    glDepthBoundsdNV,
    glDepthRangeArraydvNV,
    glDepthRangeArrayv,
    glDepthRangeIndexed,
    glDepthRangeIndexeddNV,
    glDepthRangedNV,
    glDepthRangef,
    glDepthRangefOES,
    glDepthRangexOES,
    glDetachObjectARB,
    glDetachShader,
    glDetailTexFuncSGIS,
    glDisableClientStateIndexedEXT,
    glDisableClientStateiEXT,
    glDisableIndexedEXT,
    glDisableVariantClientStateEXT,
    glDisableVertexArrayAttrib,
    glDisableVertexArrayAttribEXT,
    glDisableVertexArrayEXT,
    glDisableVertexAttribAPPLE,
    glDisableVertexAttribArray,
    glDisableVertexAttribArrayARB,
    glDisablei,
    glDispatchCompute,
    glDispatchComputeGroupSizeARB,
    glDispatchComputeIndirect,
    glDrawArraysEXT,
    glDrawArraysIndirect,
    glDrawArraysInstanced,
    glDrawArraysInstancedARB,
    glDrawArraysInstancedBaseInstance,
    glDrawArraysInstancedEXT,
    glDrawBufferRegion,
    glDrawBuffers,
    glDrawBuffersARB,
    glDrawBuffersATI,
    glDrawCommandsAddressNV,
    glDrawCommandsNV,
    glDrawCommandsStatesAddressNV,
    glDrawCommandsStatesNV,
    glDrawElementArrayAPPLE,
    glDrawElementArrayATI,
    glDrawElementsBaseVertex,
    glDrawElementsIndirect,
    glDrawElementsInstanced,
    glDrawElementsInstancedARB,
    glDrawElementsInstancedBaseInstance,
    glDrawElementsInstancedBaseVertex,
    glDrawElementsInstancedBaseVertexBaseInstance,
    glDrawElementsInstancedEXT,
    glDrawMeshArraysSUN,
    glDrawMeshTasksIndirectNV,
    glDrawMeshTasksNV,
    glDrawRangeElementArrayAPPLE,
    glDrawRangeElementArrayATI,
    glDrawRangeElements,
    glDrawRangeElementsBaseVertex,
    glDrawRangeElementsEXT,
    glDrawTextureNV,
    glDrawTransformFeedback,
    glDrawTransformFeedbackInstanced,
    glDrawTransformFeedbackNV,
    glDrawTransformFeedbackStream,
    glDrawTransformFeedbackStreamInstanced,
    glDrawVkImageNV,
    glEGLImageTargetTexStorageEXT,
    glEGLImageTargetTextureStorageEXT,
    glEdgeFlagFormatNV,
    glEdgeFlagPointerEXT,
    glEdgeFlagPointerListIBM,
    glElementPointerAPPLE,
    glElementPointerATI,
    glEnableClientStateIndexedEXT,
    glEnableClientStateiEXT,
    glEnableIndexedEXT,
    glEnableVariantClientStateEXT,
    glEnableVertexArrayAttrib,
    glEnableVertexArrayAttribEXT,
    glEnableVertexArrayEXT,
    glEnableVertexAttribAPPLE,
    glEnableVertexAttribArray,
    glEnableVertexAttribArrayARB,
    glEnablei,
    glEndConditionalRender,
    glEndConditionalRenderNV,
    glEndConditionalRenderNVX,
    glEndFragmentShaderATI,
    glEndOcclusionQueryNV,
    glEndPerfMonitorAMD,
    glEndPerfQueryINTEL,
    glEndQuery,
    glEndQueryARB,
    glEndQueryIndexed,
    glEndTransformFeedback,
    glEndTransformFeedbackEXT,
    glEndTransformFeedbackNV,
    glEndVertexShaderEXT,
    glEndVideoCaptureNV,
    glEvalCoord1xOES,
    glEvalCoord1xvOES,
    glEvalCoord2xOES,
    glEvalCoord2xvOES,
    glEvalMapsNV,
    glEvaluateDepthValuesARB,
    glExecuteProgramNV,
    glExtractComponentEXT,
    glFeedbackBufferxOES,
    glFenceSync,
    glFinalCombinerInputNV,
    glFinishAsyncSGIX,
    glFinishFenceAPPLE,
    glFinishFenceNV,
    glFinishObjectAPPLE,
    glFinishTextureSUNX,
    glFlushMappedBufferRange,
    glFlushMappedBufferRangeAPPLE,
    glFlushMappedNamedBufferRange,
    glFlushMappedNamedBufferRangeEXT,
    glFlushPixelDataRangeNV,
    glFlushRasterSGIX,
    glFlushStaticDataIBM,
    glFlushVertexArrayRangeAPPLE,
    glFlushVertexArrayRangeNV,
    glFogCoordFormatNV,
    glFogCoordPointer,
    glFogCoordPointerEXT,
    glFogCoordPointerListIBM,
    glFogCoordd,
    glFogCoorddEXT,
    glFogCoorddv,
    glFogCoorddvEXT,
    glFogCoordf,
    glFogCoordfEXT,
    glFogCoordfv,
    glFogCoordfvEXT,
    glFogCoordhNV,
    glFogCoordhvNV,
    glFogFuncSGIS,
    glFogxOES,
    glFogxvOES,
    glFragmentColorMaterialSGIX,
    glFragmentCoverageColorNV,
    glFragmentLightModelfSGIX,
    glFragmentLightModelfvSGIX,
    glFragmentLightModeliSGIX,
    glFragmentLightModelivSGIX,
    glFragmentLightfSGIX,
    glFragmentLightfvSGIX,
    glFragmentLightiSGIX,
    glFragmentLightivSGIX,
    glFragmentMaterialfSGIX,
    glFragmentMaterialfvSGIX,
    glFragmentMaterialiSGIX,
    glFragmentMaterialivSGIX,
    glFrameTerminatorGREMEDY,
    glFrameZoomSGIX,
    glFramebufferDrawBufferEXT,
    glFramebufferDrawBuffersEXT,
    glFramebufferFetchBarrierEXT,
    glFramebufferParameteri,
    glFramebufferParameteriMESA,
    glFramebufferReadBufferEXT,
    glFramebufferRenderbuffer,
    glFramebufferRenderbufferEXT,
    glFramebufferSampleLocationsfvARB,
    glFramebufferSampleLocationsfvNV,
    glFramebufferSamplePositionsfvAMD,
    glFramebufferTexture,
    glFramebufferTexture1D,
    glFramebufferTexture1DEXT,
    glFramebufferTexture2D,
    glFramebufferTexture2DEXT,
    glFramebufferTexture3D,
    glFramebufferTexture3DEXT,
    glFramebufferTextureARB,
    glFramebufferTextureEXT,
    glFramebufferTextureFaceARB,
    glFramebufferTextureFaceEXT,
    glFramebufferTextureLayer,
    glFramebufferTextureLayerARB,
    glFramebufferTextureLayerEXT,
    glFramebufferTextureMultiviewOVR,
    glFreeObjectBufferATI,
    glFrustumfOES,
    glFrustumxOES,
    glGenAsyncMarkersSGIX,
    glGenBuffers,
    glGenBuffersARB,
    glGenFencesAPPLE,
    glGenFencesNV,
    glGenFragmentShadersATI,
    glGenFramebuffers,
    glGenFramebuffersEXT,
    glGenNamesAMD,
    glGenOcclusionQueriesNV,
    glGenPathsNV,
    glGenPerfMonitorsAMD,
    glGenProgramPipelines,
    glGenProgramsARB,
    glGenProgramsNV,
    glGenQueries,
    glGenQueriesARB,
    glGenQueryResourceTagNV,
    glGenRenderbuffers,
    glGenRenderbuffersEXT,
    glGenSamplers,
    glGenSemaphoresEXT,
    glGenSymbolsEXT,
    glGenTexturesEXT,
    glGenTransformFeedbacks,
    glGenTransformFeedbacksNV,
    glGenVertexArrays,
    glGenVertexArraysAPPLE,
    glGenVertexShadersEXT,
    glGenerateMipmap,
    glGenerateMipmapEXT,
    glGenerateMultiTexMipmapEXT,
    glGenerateTextureMipmap,
    glGenerateTextureMipmapEXT,
    glGetActiveAtomicCounterBufferiv,
    glGetActiveAttrib,
    glGetActiveAttribARB,
    glGetActiveSubroutineName,
    glGetActiveSubroutineUniformName,
    glGetActiveSubroutineUniformiv,
    glGetActiveUniform,
    glGetActiveUniformARB,
    glGetActiveUniformBlockName,
    glGetActiveUniformBlockiv,
    glGetActiveUniformName,
    glGetActiveUniformsiv,
    glGetActiveVaryingNV,
    glGetArrayObjectfvATI,
    glGetArrayObjectivATI,
    glGetAttachedObjectsARB,
    glGetAttachedShaders,
    glGetAttribLocation,
    glGetAttribLocationARB,
    glGetBooleanIndexedvEXT,
    glGetBooleani_v,
    glGetBufferParameteri64v,
    glGetBufferParameteriv,
    glGetBufferParameterivARB,
    glGetBufferParameterui64vNV,
    glGetBufferPointerv,
    glGetBufferPointervARB,
    glGetBufferSubData,
    glGetBufferSubDataARB,
    glGetClipPlanefOES,
    glGetClipPlanexOES,
    glGetColorTable,
    glGetColorTableEXT,
    glGetColorTableParameterfv,
    glGetColorTableParameterfvEXT,
    glGetColorTableParameterfvSGI,
    glGetColorTableParameteriv,
    glGetColorTableParameterivEXT,
    glGetColorTableParameterivSGI,
    glGetColorTableSGI,
    glGetCombinerInputParameterfvNV,
    glGetCombinerInputParameterivNV,
    glGetCombinerOutputParameterfvNV,
    glGetCombinerOutputParameterivNV,
    glGetCombinerStageParameterfvNV,
    glGetCommandHeaderNV,
    glGetCompressedMultiTexImageEXT,
    glGetCompressedTexImage,
    glGetCompressedTexImageARB,
    glGetCompressedTextureImage,
    glGetCompressedTextureImageEXT,
    glGetCompressedTextureSubImage,
    glGetConvolutionFilter,
    glGetConvolutionFilterEXT,
    glGetConvolutionParameterfv,
    glGetConvolutionParameterfvEXT,
    glGetConvolutionParameteriv,
    glGetConvolutionParameterivEXT,
    glGetConvolutionParameterxvOES,
    glGetCoverageModulationTableNV,
    glGetDebugMessageLog,
    glGetDebugMessageLogAMD,
    glGetDebugMessageLogARB,
    glGetDetailTexFuncSGIS,
    glGetDoubleIndexedvEXT,
    glGetDoublei_v,
    glGetDoublei_vEXT,
    glGetFenceivNV,
    glGetFinalCombinerInputParameterfvNV,
    glGetFinalCombinerInputParameterivNV,
    glGetFirstPerfQueryIdINTEL,
    glGetFixedvOES,
    glGetFloatIndexedvEXT,
    glGetFloati_v,
    glGetFloati_vEXT,
    glGetFogFuncSGIS,
    glGetFragDataIndex,
    glGetFragDataLocation,
    glGetFragDataLocationEXT,
    glGetFragmentLightfvSGIX,
    glGetFragmentLightivSGIX,
    glGetFragmentMaterialfvSGIX,
    glGetFragmentMaterialivSGIX,
    glGetFramebufferAttachmentParameteriv,
    glGetFramebufferAttachmentParameterivEXT,
    glGetFramebufferParameterfvAMD,
    glGetFramebufferParameteriv,
    glGetFramebufferParameterivEXT,
    glGetFramebufferParameterivMESA,
    glGetGraphicsResetStatus,
    glGetGraphicsResetStatusARB,
    glGetHandleARB,
    glGetHistogram,
    glGetHistogramEXT,
    glGetHistogramParameterfv,
    glGetHistogramParameterfvEXT,
    glGetHistogramParameteriv,
    glGetHistogramParameterivEXT,
    glGetHistogramParameterxvOES,
    glGetImageHandleARB,
    glGetImageHandleNV,
    glGetImageTransformParameterfvHP,
    glGetImageTransformParameterivHP,
    glGetInfoLogARB,
    glGetInstrumentsSGIX,
    glGetInteger64i_v,
    glGetInteger64v,
    glGetIntegerIndexedvEXT,
    glGetIntegeri_v,
    glGetIntegerui64i_vNV,
    glGetIntegerui64vNV,
    glGetInternalformatSampleivNV,
    glGetInternalformati64v,
    glGetInternalformativ,
    glGetInvariantBooleanvEXT,
    glGetInvariantFloatvEXT,
    glGetInvariantIntegervEXT,
    glGetLightxOES,
    glGetListParameterfvSGIX,
    glGetListParameterivSGIX,
    glGetLocalConstantBooleanvEXT,
    glGetLocalConstantFloatvEXT,
    glGetLocalConstantIntegervEXT,
    glGetMapAttribParameterfvNV,
    glGetMapAttribParameterivNV,
    glGetMapControlPointsNV,
    glGetMapParameterfvNV,
    glGetMapParameterivNV,
    glGetMapxvOES,
    glGetMaterialxOES,
    glGetMemoryObjectDetachedResourcesuivNV,
    glGetMemoryObjectParameterivEXT,
    glGetMinmax,
    glGetMinmaxEXT,
    glGetMinmaxParameterfv,
    glGetMinmaxParameterfvEXT,
    glGetMinmaxParameteriv,
    glGetMinmaxParameterivEXT,
    glGetMultiTexEnvfvEXT,
    glGetMultiTexEnvivEXT,
    glGetMultiTexGendvEXT,
    glGetMultiTexGenfvEXT,
    glGetMultiTexGenivEXT,
    glGetMultiTexImageEXT,
    glGetMultiTexLevelParameterfvEXT,
    glGetMultiTexLevelParameterivEXT,
    glGetMultiTexParameterIivEXT,
    glGetMultiTexParameterIuivEXT,
    glGetMultiTexParameterfvEXT,
    glGetMultiTexParameterivEXT,
    glGetMultisamplefv,
    glGetMultisamplefvNV,
    glGetNamedBufferParameteri64v,
    glGetNamedBufferParameteriv,
    glGetNamedBufferParameterivEXT,
    glGetNamedBufferParameterui64vNV,
    glGetNamedBufferPointerv,
    glGetNamedBufferPointervEXT,
    glGetNamedBufferSubData,
    glGetNamedBufferSubDataEXT,
    glGetNamedFramebufferAttachmentParameteriv,
    glGetNamedFramebufferAttachmentParameterivEXT,
    glGetNamedFramebufferParameterfvAMD,
    glGetNamedFramebufferParameteriv,
    glGetNamedFramebufferParameterivEXT,
    glGetNamedProgramLocalParameterIivEXT,
    glGetNamedProgramLocalParameterIuivEXT,
    glGetNamedProgramLocalParameterdvEXT,
    glGetNamedProgramLocalParameterfvEXT,
    glGetNamedProgramStringEXT,
    glGetNamedProgramivEXT,
    glGetNamedRenderbufferParameteriv,
    glGetNamedRenderbufferParameterivEXT,
    glGetNamedStringARB,
    glGetNamedStringivARB,
    glGetNextPerfQueryIdINTEL,
    glGetObjectBufferfvATI,
    glGetObjectBufferivATI,
    glGetObjectLabel,
    glGetObjectLabelEXT,
    glGetObjectParameterfvARB,
    glGetObjectParameterivAPPLE,
    glGetObjectParameterivARB,
    glGetObjectPtrLabel,
    glGetOcclusionQueryivNV,
    glGetOcclusionQueryuivNV,
    glGetPathColorGenfvNV,
    glGetPathColorGenivNV,
    glGetPathCommandsNV,
    glGetPathCoordsNV,
    glGetPathDashArrayNV,
    glGetPathLengthNV,
    glGetPathMetricRangeNV,
    glGetPathMetricsNV,
    glGetPathParameterfvNV,
    glGetPathParameterivNV,
    glGetPathSpacingNV,
    glGetPathTexGenfvNV,
    glGetPathTexGenivNV,
    glGetPerfCounterInfoINTEL,
    glGetPerfMonitorCounterDataAMD,
    glGetPerfMonitorCounterInfoAMD,
    glGetPerfMonitorCounterStringAMD,
    glGetPerfMonitorCountersAMD,
    glGetPerfMonitorGroupStringAMD,
    glGetPerfMonitorGroupsAMD,
    glGetPerfQueryDataINTEL,
    glGetPerfQueryIdByNameINTEL,
    glGetPerfQueryInfoINTEL,
    glGetPixelMapxv,
    glGetPixelTexGenParameterfvSGIS,
    glGetPixelTexGenParameterivSGIS,
    glGetPixelTransformParameterfvEXT,
    glGetPixelTransformParameterivEXT,
    glGetPointerIndexedvEXT,
    glGetPointeri_vEXT,
    glGetPointervEXT,
    glGetProgramBinary,
    glGetProgramEnvParameterIivNV,
    glGetProgramEnvParameterIuivNV,
    glGetProgramEnvParameterdvARB,
    glGetProgramEnvParameterfvARB,
    glGetProgramInfoLog,
    glGetProgramInterfaceiv,
    glGetProgramLocalParameterIivNV,
    glGetProgramLocalParameterIuivNV,
    glGetProgramLocalParameterdvARB,
    glGetProgramLocalParameterfvARB,
    glGetProgramNamedParameterdvNV,
    glGetProgramNamedParameterfvNV,
    glGetProgramParameterdvNV,
    glGetProgramParameterfvNV,
    glGetProgramPipelineInfoLog,
    glGetProgramPipelineiv,
    glGetProgramResourceIndex,
    glGetProgramResourceLocation,
    glGetProgramResourceLocationIndex,
    glGetProgramResourceName,
    glGetProgramResourcefvNV,
    glGetProgramResourceiv,
    glGetProgramStageiv,
    glGetProgramStringARB,
    glGetProgramStringNV,
    glGetProgramSubroutineParameteruivNV,
    glGetProgramiv,
    glGetProgramivARB,
    glGetProgramivNV,
    glGetQueryBufferObjecti64v,
    glGetQueryBufferObjectiv,
    glGetQueryBufferObjectui64v,
    glGetQueryBufferObjectuiv,
    glGetQueryIndexediv,
    glGetQueryObjecti64v,
    glGetQueryObjecti64vEXT,
    glGetQueryObjectiv,
    glGetQueryObjectivARB,
    glGetQueryObjectui64v,
    glGetQueryObjectui64vEXT,
    glGetQueryObjectuiv,
    glGetQueryObjectuivARB,
    glGetQueryiv,
    glGetQueryivARB,
    glGetRenderbufferParameteriv,
    glGetRenderbufferParameterivEXT,
    glGetSamplerParameterIiv,
    glGetSamplerParameterIuiv,
    glGetSamplerParameterfv,
    glGetSamplerParameteriv,
    glGetSemaphoreParameterui64vEXT,
    glGetSeparableFilter,
    glGetSeparableFilterEXT,
    glGetShaderInfoLog,
    glGetShaderPrecisionFormat,
    glGetShaderSource,
    glGetShaderSourceARB,
    glGetShaderiv,
    glGetShadingRateImagePaletteNV,
    glGetShadingRateSampleLocationivNV,
    glGetSharpenTexFuncSGIS,
    glGetStageIndexNV,
    glGetStringi,
    glGetSubroutineIndex,
    glGetSubroutineUniformLocation,
    glGetSynciv,
    glGetTexBumpParameterfvATI,
    glGetTexBumpParameterivATI,
    glGetTexEnvxvOES,
    glGetTexFilterFuncSGIS,
    glGetTexGenxvOES,
    glGetTexLevelParameterxvOES,
    glGetTexParameterIiv,
    glGetTexParameterIivEXT,
    glGetTexParameterIuiv,
    glGetTexParameterIuivEXT,
    glGetTexParameterPointervAPPLE,
    glGetTexParameterxvOES,
    glGetTextureHandleARB,
    glGetTextureHandleNV,
    glGetTextureImage,
    glGetTextureImageEXT,
    glGetTextureLevelParameterfv,
    glGetTextureLevelParameterfvEXT,
    glGetTextureLevelParameteriv,
    glGetTextureLevelParameterivEXT,
    glGetTextureParameterIiv,
    glGetTextureParameterIivEXT,
    glGetTextureParameterIuiv,
    glGetTextureParameterIuivEXT,
    glGetTextureParameterfv,
    glGetTextureParameterfvEXT,
    glGetTextureParameteriv,
    glGetTextureParameterivEXT,
    glGetTextureSamplerHandleARB,
    glGetTextureSamplerHandleNV,
    glGetTextureSubImage,
    glGetTrackMatrixivNV,
    glGetTransformFeedbackVarying,
    glGetTransformFeedbackVaryingEXT,
    glGetTransformFeedbackVaryingNV,
    glGetTransformFeedbacki64_v,
    glGetTransformFeedbacki_v,
    glGetTransformFeedbackiv,
    glGetUniformBlockIndex,
    glGetUniformBufferSizeEXT,
    glGetUniformIndices,
    glGetUniformLocation,
    glGetUniformLocationARB,
    glGetUniformOffsetEXT,
    glGetUniformSubroutineuiv,
    glGetUniformdv,
    glGetUniformfv,
    glGetUniformfvARB,
    glGetUniformi64vARB,
    glGetUniformi64vNV,
    glGetUniformiv,
    glGetUniformivARB,
    glGetUniformui64vARB,
    glGetUniformui64vNV,
    glGetUniformuiv,
    glGetUniformuivEXT,
    glGetUnsignedBytei_vEXT,
    glGetUnsignedBytevEXT,
    glGetVariantArrayObjectfvATI,
    glGetVariantArrayObjectivATI,
    glGetVariantBooleanvEXT,
    glGetVariantFloatvEXT,
    glGetVariantIntegervEXT,
    glGetVariantPointervEXT,
    glGetVaryingLocationNV,
    glGetVertexArrayIndexed64iv,
    glGetVertexArrayIndexediv,
    glGetVertexArrayIntegeri_vEXT,
    glGetVertexArrayIntegervEXT,
    glGetVertexArrayPointeri_vEXT,
    glGetVertexArrayPointervEXT,
    glGetVertexArrayiv,
    glGetVertexAttribArrayObjectfvATI,
    glGetVertexAttribArrayObjectivATI,
    glGetVertexAttribIiv,
    glGetVertexAttribIivEXT,
    glGetVertexAttribIuiv,
    glGetVertexAttribIuivEXT,
    glGetVertexAttribLdv,
    glGetVertexAttribLdvEXT,
    glGetVertexAttribLi64vNV,
    glGetVertexAttribLui64vARB,
    glGetVertexAttribLui64vNV,
    glGetVertexAttribPointerv,
    glGetVertexAttribPointervARB,
    glGetVertexAttribPointervNV,
    glGetVertexAttribdv,
    glGetVertexAttribdvARB,
    glGetVertexAttribdvNV,
    glGetVertexAttribfv,
    glGetVertexAttribfvARB,
    glGetVertexAttribfvNV,
    glGetVertexAttribiv,
    glGetVertexAttribivARB,
    glGetVertexAttribivNV,
    glGetVideoCaptureStreamdvNV,
    glGetVideoCaptureStreamfvNV,
    glGetVideoCaptureStreamivNV,
    glGetVideoCaptureivNV,
    glGetVideoi64vNV,
    glGetVideoivNV,
    glGetVideoui64vNV,
    glGetVideouivNV,
    glGetVkProcAddrNV,
    glGetnColorTable,
    glGetnColorTableARB,
    glGetnCompressedTexImage,
    glGetnCompressedTexImageARB,
    glGetnConvolutionFilter,
    glGetnConvolutionFilterARB,
    glGetnHistogram,
    glGetnHistogramARB,
    glGetnMapdv,
    glGetnMapdvARB,
    glGetnMapfv,
    glGetnMapfvARB,
    glGetnMapiv,
    glGetnMapivARB,
    glGetnMinmax,
    glGetnMinmaxARB,
    glGetnPixelMapfv,
    glGetnPixelMapfvARB,
    glGetnPixelMapuiv,
    glGetnPixelMapuivARB,
    glGetnPixelMapusv,
    glGetnPixelMapusvARB,
    glGetnPolygonStipple,
    glGetnPolygonStippleARB,
    glGetnSeparableFilter,
    glGetnSeparableFilterARB,
    glGetnTexImage,
    glGetnTexImageARB,
    glGetnUniformdv,
    glGetnUniformdvARB,
    glGetnUniformfv,
    glGetnUniformfvARB,
    glGetnUniformi64vARB,
    glGetnUniformiv,
    glGetnUniformivARB,
    glGetnUniformui64vARB,
    glGetnUniformuiv,
    glGetnUniformuivARB,
    glGlobalAlphaFactorbSUN,
    glGlobalAlphaFactordSUN,
    glGlobalAlphaFactorfSUN,
    glGlobalAlphaFactoriSUN,
    glGlobalAlphaFactorsSUN,
    glGlobalAlphaFactorubSUN,
    glGlobalAlphaFactoruiSUN,
    glGlobalAlphaFactorusSUN,
    glHintPGI,
    glHistogram,
    glHistogramEXT,
    glIglooInterfaceSGIX,
    glImageTransformParameterfHP,
    glImageTransformParameterfvHP,
    glImageTransformParameteriHP,
    glImageTransformParameterivHP,
    glImportMemoryFdEXT,
    glImportMemoryWin32HandleEXT,
    glImportMemoryWin32NameEXT,
    glImportSemaphoreFdEXT,
    glImportSemaphoreWin32HandleEXT,
    glImportSemaphoreWin32NameEXT,
    glImportSyncEXT,
    glIndexFormatNV,
    glIndexFuncEXT,
    glIndexMaterialEXT,
    glIndexPointerEXT,
    glIndexPointerListIBM,
    glIndexxOES,
    glIndexxvOES,
    glInsertComponentEXT,
    glInsertEventMarkerEXT,
    glInstrumentsBufferSGIX,
    glInterpolatePathsNV,
    glInvalidateBufferData,
    glInvalidateBufferSubData,
    glInvalidateFramebuffer,
    glInvalidateNamedFramebufferData,
    glInvalidateNamedFramebufferSubData,
    glInvalidateSubFramebuffer,
    glInvalidateTexImage,
    glInvalidateTexSubImage,
    glIsAsyncMarkerSGIX,
    glIsBuffer,
    glIsBufferARB,
    glIsBufferResidentNV,
    glIsCommandListNV,
    glIsEnabledIndexedEXT,
    glIsEnabledi,
    glIsFenceAPPLE,
    glIsFenceNV,
    glIsFramebuffer,
    glIsFramebufferEXT,
    glIsImageHandleResidentARB,
    glIsImageHandleResidentNV,
    glIsMemoryObjectEXT,
    glIsNameAMD,
    glIsNamedBufferResidentNV,
    glIsNamedStringARB,
    glIsObjectBufferATI,
    glIsOcclusionQueryNV,
    glIsPathNV,
    glIsPointInFillPathNV,
    glIsPointInStrokePathNV,
    glIsProgram,
    glIsProgramARB,
    glIsProgramNV,
    glIsProgramPipeline,
    glIsQuery,
    glIsQueryARB,
    glIsRenderbuffer,
    glIsRenderbufferEXT,
    glIsSampler,
    glIsSemaphoreEXT,
    glIsShader,
    glIsStateNV,
    glIsSync,
    glIsTextureEXT,
    glIsTextureHandleResidentARB,
    glIsTextureHandleResidentNV,
    glIsTransformFeedback,
    glIsTransformFeedbackNV,
    glIsVariantEnabledEXT,
    glIsVertexArray,
    glIsVertexArrayAPPLE,
    glIsVertexAttribEnabledAPPLE,
    glLGPUCopyImageSubDataNVX,
    glLGPUInterlockNVX,
    glLGPUNamedBufferSubDataNVX,
    glLabelObjectEXT,
    glLightEnviSGIX,
    glLightModelxOES,
    glLightModelxvOES,
    glLightxOES,
    glLightxvOES,
    glLineWidthxOES,
    glLinkProgram,
    glLinkProgramARB,
    glListDrawCommandsStatesClientNV,
    glListParameterfSGIX,
    glListParameterfvSGIX,
    glListParameteriSGIX,
    glListParameterivSGIX,
    glLoadIdentityDeformationMapSGIX,
    glLoadMatrixxOES,
    glLoadProgramNV,
    glLoadTransposeMatrixd,
    glLoadTransposeMatrixdARB,
    glLoadTransposeMatrixf,
    glLoadTransposeMatrixfARB,
    glLoadTransposeMatrixxOES,
    glLockArraysEXT,
    glMTexCoord2fSGIS,
    glMTexCoord2fvSGIS,
    glMakeBufferNonResidentNV,
    glMakeBufferResidentNV,
    glMakeImageHandleNonResidentARB,
    glMakeImageHandleNonResidentNV,
    glMakeImageHandleResidentARB,
    glMakeImageHandleResidentNV,
    glMakeNamedBufferNonResidentNV,
    glMakeNamedBufferResidentNV,
    glMakeTextureHandleNonResidentARB,
    glMakeTextureHandleNonResidentNV,
    glMakeTextureHandleResidentARB,
    glMakeTextureHandleResidentNV,
    glMap1xOES,
    glMap2xOES,
    glMapBuffer,
    glMapBufferARB,
    glMapBufferRange,
    glMapControlPointsNV,
    glMapGrid1xOES,
    glMapGrid2xOES,
    glMapNamedBuffer,
    glMapNamedBufferEXT,
    glMapNamedBufferRange,
    glMapNamedBufferRangeEXT,
    glMapObjectBufferATI,
    glMapParameterfvNV,
    glMapParameterivNV,
    glMapTexture2DINTEL,
    glMapVertexAttrib1dAPPLE,
    glMapVertexAttrib1fAPPLE,
    glMapVertexAttrib2dAPPLE,
    glMapVertexAttrib2fAPPLE,
    glMaterialxOES,
    glMaterialxvOES,
    glMatrixFrustumEXT,
    glMatrixIndexPointerARB,
    glMatrixIndexubvARB,
    glMatrixIndexuivARB,
    glMatrixIndexusvARB,
    glMatrixLoad3x2fNV,
    glMatrixLoad3x3fNV,
    glMatrixLoadIdentityEXT,
    glMatrixLoadTranspose3x3fNV,
    glMatrixLoadTransposedEXT,
    glMatrixLoadTransposefEXT,
    glMatrixLoaddEXT,
    glMatrixLoadfEXT,
    glMatrixMult3x2fNV,
    glMatrixMult3x3fNV,
    glMatrixMultTranspose3x3fNV,
    glMatrixMultTransposedEXT,
    glMatrixMultTransposefEXT,
    glMatrixMultdEXT,
    glMatrixMultfEXT,
    glMatrixOrthoEXT,
    glMatrixPopEXT,
    glMatrixPushEXT,
    glMatrixRotatedEXT,
    glMatrixRotatefEXT,
    glMatrixScaledEXT,
    glMatrixScalefEXT,
    glMatrixTranslatedEXT,
    glMatrixTranslatefEXT,
    glMaxShaderCompilerThreadsARB,
    glMaxShaderCompilerThreadsKHR,
    glMemoryBarrier,
    glMemoryBarrierByRegion,
    glMemoryBarrierEXT,
    glMemoryObjectParameterivEXT,
    glMinSampleShading,
    glMinSampleShadingARB,
    glMinmax,
    glMinmaxEXT,
    glMultMatrixxOES,
    glMultTransposeMatrixd,
    glMultTransposeMatrixdARB,
    glMultTransposeMatrixf,
    glMultTransposeMatrixfARB,
    glMultTransposeMatrixxOES,
    glMultiDrawArrays,
    glMultiDrawArraysEXT,
    glMultiDrawArraysIndirect,
    glMultiDrawArraysIndirectAMD,
    glMultiDrawArraysIndirectBindlessCountNV,
    glMultiDrawArraysIndirectBindlessNV,
    glMultiDrawArraysIndirectCount,
    glMultiDrawArraysIndirectCountARB,
    glMultiDrawElementArrayAPPLE,
    glMultiDrawElements,
    glMultiDrawElementsBaseVertex,
    glMultiDrawElementsEXT,
    glMultiDrawElementsIndirect,
    glMultiDrawElementsIndirectAMD,
    glMultiDrawElementsIndirectBindlessCountNV,
    glMultiDrawElementsIndirectBindlessNV,
    glMultiDrawElementsIndirectCount,
    glMultiDrawElementsIndirectCountARB,
    glMultiDrawMeshTasksIndirectCountNV,
    glMultiDrawMeshTasksIndirectNV,
    glMultiDrawRangeElementArrayAPPLE,
    glMultiModeDrawArraysIBM,
    glMultiModeDrawElementsIBM,
    glMultiTexBufferEXT,
    glMultiTexCoord1bOES,
    glMultiTexCoord1bvOES,
    glMultiTexCoord1d,
    glMultiTexCoord1dARB,
    glMultiTexCoord1dSGIS,
    glMultiTexCoord1dv,
    glMultiTexCoord1dvARB,
    glMultiTexCoord1dvSGIS,
    glMultiTexCoord1f,
    glMultiTexCoord1fARB,
    glMultiTexCoord1fSGIS,
    glMultiTexCoord1fv,
    glMultiTexCoord1fvARB,
    glMultiTexCoord1fvSGIS,
    glMultiTexCoord1hNV,
    glMultiTexCoord1hvNV,
    glMultiTexCoord1i,
    glMultiTexCoord1iARB,
    glMultiTexCoord1iSGIS,
    glMultiTexCoord1iv,
    glMultiTexCoord1ivARB,
    glMultiTexCoord1ivSGIS,
    glMultiTexCoord1s,
    glMultiTexCoord1sARB,
    glMultiTexCoord1sSGIS,
    glMultiTexCoord1sv,
    glMultiTexCoord1svARB,
    glMultiTexCoord1svSGIS,
    glMultiTexCoord1xOES,
    glMultiTexCoord1xvOES,
    glMultiTexCoord2bOES,
    glMultiTexCoord2bvOES,
    glMultiTexCoord2d,
    glMultiTexCoord2dARB,
    glMultiTexCoord2dSGIS,
    glMultiTexCoord2dv,
    glMultiTexCoord2dvARB,
    glMultiTexCoord2dvSGIS,
    glMultiTexCoord2f,
    glMultiTexCoord2fARB,
    glMultiTexCoord2fSGIS,
    glMultiTexCoord2fv,
    glMultiTexCoord2fvARB,
    glMultiTexCoord2fvSGIS,
    glMultiTexCoord2hNV,
    glMultiTexCoord2hvNV,
    glMultiTexCoord2i,
    glMultiTexCoord2iARB,
    glMultiTexCoord2iSGIS,
    glMultiTexCoord2iv,
    glMultiTexCoord2ivARB,
    glMultiTexCoord2ivSGIS,
    glMultiTexCoord2s,
    glMultiTexCoord2sARB,
    glMultiTexCoord2sSGIS,
    glMultiTexCoord2sv,
    glMultiTexCoord2svARB,
    glMultiTexCoord2svSGIS,
    glMultiTexCoord2xOES,
    glMultiTexCoord2xvOES,
    glMultiTexCoord3bOES,
    glMultiTexCoord3bvOES,
    glMultiTexCoord3d,
    glMultiTexCoord3dARB,
    glMultiTexCoord3dSGIS,
    glMultiTexCoord3dv,
    glMultiTexCoord3dvARB,
    glMultiTexCoord3dvSGIS,
    glMultiTexCoord3f,
    glMultiTexCoord3fARB,
    glMultiTexCoord3fSGIS,
    glMultiTexCoord3fv,
    glMultiTexCoord3fvARB,
    glMultiTexCoord3fvSGIS,
    glMultiTexCoord3hNV,
    glMultiTexCoord3hvNV,
    glMultiTexCoord3i,
    glMultiTexCoord3iARB,
    glMultiTexCoord3iSGIS,
    glMultiTexCoord3iv,
    glMultiTexCoord3ivARB,
    glMultiTexCoord3ivSGIS,
    glMultiTexCoord3s,
    glMultiTexCoord3sARB,
    glMultiTexCoord3sSGIS,
    glMultiTexCoord3sv,
    glMultiTexCoord3svARB,
    glMultiTexCoord3svSGIS,
    glMultiTexCoord3xOES,
    glMultiTexCoord3xvOES,
    glMultiTexCoord4bOES,
    glMultiTexCoord4bvOES,
    glMultiTexCoord4d,
    glMultiTexCoord4dARB,
    glMultiTexCoord4dSGIS,
    glMultiTexCoord4dv,
    glMultiTexCoord4dvARB,
    glMultiTexCoord4dvSGIS,
    glMultiTexCoord4f,
    glMultiTexCoord4fARB,
    glMultiTexCoord4fSGIS,
    glMultiTexCoord4fv,
    glMultiTexCoord4fvARB,
    glMultiTexCoord4fvSGIS,
    glMultiTexCoord4hNV,
    glMultiTexCoord4hvNV,
    glMultiTexCoord4i,
    glMultiTexCoord4iARB,
    glMultiTexCoord4iSGIS,
    glMultiTexCoord4iv,
    glMultiTexCoord4ivARB,
    glMultiTexCoord4ivSGIS,
    glMultiTexCoord4s,
    glMultiTexCoord4sARB,
    glMultiTexCoord4sSGIS,
    glMultiTexCoord4sv,
    glMultiTexCoord4svARB,
    glMultiTexCoord4svSGIS,
    glMultiTexCoord4xOES,
    glMultiTexCoord4xvOES,
    glMultiTexCoordP1ui,
    glMultiTexCoordP1uiv,
    glMultiTexCoordP2ui,
    glMultiTexCoordP2uiv,
    glMultiTexCoordP3ui,
    glMultiTexCoordP3uiv,
    glMultiTexCoordP4ui,
    glMultiTexCoordP4uiv,
    glMultiTexCoordPointerEXT,
    glMultiTexCoordPointerSGIS,
    glMultiTexEnvfEXT,
    glMultiTexEnvfvEXT,
    glMultiTexEnviEXT,
    glMultiTexEnvivEXT,
    glMultiTexGendEXT,
    glMultiTexGendvEXT,
    glMultiTexGenfEXT,
    glMultiTexGenfvEXT,
    glMultiTexGeniEXT,
    glMultiTexGenivEXT,
    glMultiTexImage1DEXT,
    glMultiTexImage2DEXT,
    glMultiTexImage3DEXT,
    glMultiTexParameterIivEXT,
    glMultiTexParameterIuivEXT,
    glMultiTexParameterfEXT,
    glMultiTexParameterfvEXT,
    glMultiTexParameteriEXT,
    glMultiTexParameterivEXT,
    glMultiTexRenderbufferEXT,
    glMultiTexSubImage1DEXT,
    glMultiTexSubImage2DEXT,
    glMultiTexSubImage3DEXT,
    glMulticastBarrierNV,
    glMulticastBlitFramebufferNV,
    glMulticastBufferSubDataNV,
    glMulticastCopyBufferSubDataNV,
    glMulticastCopyImageSubDataNV,
    glMulticastFramebufferSampleLocationsfvNV,
    glMulticastGetQueryObjecti64vNV,
    glMulticastGetQueryObjectivNV,
    glMulticastGetQueryObjectui64vNV,
    glMulticastGetQueryObjectuivNV,
    glMulticastScissorArrayvNVX,
    glMulticastViewportArrayvNVX,
    glMulticastViewportPositionWScaleNVX,
    glMulticastWaitSyncNV,
    glNamedBufferAttachMemoryNV,
    glNamedBufferData,
    glNamedBufferDataEXT,
    glNamedBufferPageCommitmentARB,
    glNamedBufferPageCommitmentEXT,
    glNamedBufferStorage,
    glNamedBufferStorageEXT,
    glNamedBufferStorageExternalEXT,
    glNamedBufferStorageMemEXT,
    glNamedBufferSubData,
    glNamedBufferSubDataEXT,
    glNamedCopyBufferSubDataEXT,
    glNamedFramebufferDrawBuffer,
    glNamedFramebufferDrawBuffers,
    glNamedFramebufferParameteri,
    glNamedFramebufferParameteriEXT,
    glNamedFramebufferReadBuffer,
    glNamedFramebufferRenderbuffer,
    glNamedFramebufferRenderbufferEXT,
    glNamedFramebufferSampleLocationsfvARB,
    glNamedFramebufferSampleLocationsfvNV,
    glNamedFramebufferSamplePositionsfvAMD,
    glNamedFramebufferTexture,
    glNamedFramebufferTexture1DEXT,
    glNamedFramebufferTexture2DEXT,
    glNamedFramebufferTexture3DEXT,
    glNamedFramebufferTextureEXT,
    glNamedFramebufferTextureFaceEXT,
    glNamedFramebufferTextureLayer,
    glNamedFramebufferTextureLayerEXT,
    glNamedProgramLocalParameter4dEXT,
    glNamedProgramLocalParameter4dvEXT,
    glNamedProgramLocalParameter4fEXT,
    glNamedProgramLocalParameter4fvEXT,
    glNamedProgramLocalParameterI4iEXT,
    glNamedProgramLocalParameterI4ivEXT,
    glNamedProgramLocalParameterI4uiEXT,
    glNamedProgramLocalParameterI4uivEXT,
    glNamedProgramLocalParameters4fvEXT,
    glNamedProgramLocalParametersI4ivEXT,
    glNamedProgramLocalParametersI4uivEXT,
    glNamedProgramStringEXT,
    glNamedRenderbufferStorage,
    glNamedRenderbufferStorageEXT,
    glNamedRenderbufferStorageMultisample,
    glNamedRenderbufferStorageMultisampleAdvancedAMD,
    glNamedRenderbufferStorageMultisampleCoverageEXT,
    glNamedRenderbufferStorageMultisampleEXT,
    glNamedStringARB,
    glNewBufferRegion,
    glNewObjectBufferATI,
    glNormal3fVertex3fSUN,
    glNormal3fVertex3fvSUN,
    glNormal3hNV,
    glNormal3hvNV,
    glNormal3xOES,
    glNormal3xvOES,
    glNormalFormatNV,
    glNormalP3ui,
    glNormalP3uiv,
    glNormalPointerEXT,
    glNormalPointerListIBM,
    glNormalPointervINTEL,
    glNormalStream3bATI,
    glNormalStream3bvATI,
    glNormalStream3dATI,
    glNormalStream3dvATI,
    glNormalStream3fATI,
    glNormalStream3fvATI,
    glNormalStream3iATI,
    glNormalStream3ivATI,
    glNormalStream3sATI,
    glNormalStream3svATI,
    glObjectLabel,
    glObjectPtrLabel,
    glObjectPurgeableAPPLE,
    glObjectUnpurgeableAPPLE,
    glOrthofOES,
    glOrthoxOES,
    glPNTrianglesfATI,
    glPNTrianglesiATI,
    glPassTexCoordATI,
    glPassThroughxOES,
    glPatchParameterfv,
    glPatchParameteri,
    glPathColorGenNV,
    glPathCommandsNV,
    glPathCoordsNV,
    glPathCoverDepthFuncNV,
    glPathDashArrayNV,
    glPathFogGenNV,
    glPathGlyphIndexArrayNV,
    glPathGlyphIndexRangeNV,
    glPathGlyphRangeNV,
    glPathGlyphsNV,
    glPathMemoryGlyphIndexArrayNV,
    glPathParameterfNV,
    glPathParameterfvNV,
    glPathParameteriNV,
    glPathParameterivNV,
    glPathStencilDepthOffsetNV,
    glPathStencilFuncNV,
    glPathStringNV,
    glPathSubCommandsNV,
    glPathSubCoordsNV,
    glPathTexGenNV,
    glPauseTransformFeedback,
    glPauseTransformFeedbackNV,
    glPixelDataRangeNV,
    glPixelMapx,
    glPixelStorex,
    glPixelTexGenParameterfSGIS,
    glPixelTexGenParameterfvSGIS,
    glPixelTexGenParameteriSGIS,
    glPixelTexGenParameterivSGIS,
    glPixelTexGenSGIX,
    glPixelTransferxOES,
    glPixelTransformParameterfEXT,
    glPixelTransformParameterfvEXT,
    glPixelTransformParameteriEXT,
    glPixelTransformParameterivEXT,
    glPixelZoomxOES,
    glPointAlongPathNV,
    glPointParameterf,
    glPointParameterfARB,
    glPointParameterfEXT,
    glPointParameterfSGIS,
    glPointParameterfv,
    glPointParameterfvARB,
    glPointParameterfvEXT,
    glPointParameterfvSGIS,
    glPointParameteri,
    glPointParameteriNV,
    glPointParameteriv,
    glPointParameterivNV,
    glPointParameterxvOES,
    glPointSizexOES,
    glPollAsyncSGIX,
    glPollInstrumentsSGIX,
    glPolygonOffsetClamp,
    glPolygonOffsetClampEXT,
    glPolygonOffsetEXT,
    glPolygonOffsetxOES,
    glPopDebugGroup,
    glPopGroupMarkerEXT,
    glPresentFrameDualFillNV,
    glPresentFrameKeyedNV,
    glPrimitiveBoundingBoxARB,
    glPrimitiveRestartIndex,
    glPrimitiveRestartIndexNV,
    glPrimitiveRestartNV,
    glPrioritizeTexturesEXT,
    glPrioritizeTexturesxOES,
    glProgramBinary,
    glProgramBufferParametersIivNV,
    glProgramBufferParametersIuivNV,
    glProgramBufferParametersfvNV,
    glProgramEnvParameter4dARB,
    glProgramEnvParameter4dvARB,
    glProgramEnvParameter4fARB,
    glProgramEnvParameter4fvARB,
    glProgramEnvParameterI4iNV,
    glProgramEnvParameterI4ivNV,
    glProgramEnvParameterI4uiNV,
    glProgramEnvParameterI4uivNV,
    glProgramEnvParameters4fvEXT,
    glProgramEnvParametersI4ivNV,
    glProgramEnvParametersI4uivNV,
    glProgramLocalParameter4dARB,
    glProgramLocalParameter4dvARB,
    glProgramLocalParameter4fARB,
    glProgramLocalParameter4fvARB,
    glProgramLocalParameterI4iNV,
    glProgramLocalParameterI4ivNV,
    glProgramLocalParameterI4uiNV,
    glProgramLocalParameterI4uivNV,
    glProgramLocalParameters4fvEXT,
    glProgramLocalParametersI4ivNV,
    glProgramLocalParametersI4uivNV,
    glProgramNamedParameter4dNV,
    glProgramNamedParameter4dvNV,
    glProgramNamedParameter4fNV,
    glProgramNamedParameter4fvNV,
    glProgramParameter4dNV,
    glProgramParameter4dvNV,
    glProgramParameter4fNV,
    glProgramParameter4fvNV,
    glProgramParameteri,
    glProgramParameteriARB,
    glProgramParameteriEXT,
    glProgramParameters4dvNV,
    glProgramParameters4fvNV,
    glProgramPathFragmentInputGenNV,
    glProgramStringARB,
    glProgramSubroutineParametersuivNV,
    glProgramUniform1d,
    glProgramUniform1dEXT,
    glProgramUniform1dv,
    glProgramUniform1dvEXT,
    glProgramUniform1f,
    glProgramUniform1fEXT,
    glProgramUniform1fv,
    glProgramUniform1fvEXT,
    glProgramUniform1i,
    glProgramUniform1i64ARB,
    glProgramUniform1i64NV,
    glProgramUniform1i64vARB,
    glProgramUniform1i64vNV,
    glProgramUniform1iEXT,
    glProgramUniform1iv,
    glProgramUniform1ivEXT,
    glProgramUniform1ui,
    glProgramUniform1ui64ARB,
    glProgramUniform1ui64NV,
    glProgramUniform1ui64vARB,
    glProgramUniform1ui64vNV,
    glProgramUniform1uiEXT,
    glProgramUniform1uiv,
    glProgramUniform1uivEXT,
    glProgramUniform2d,
    glProgramUniform2dEXT,
    glProgramUniform2dv,
    glProgramUniform2dvEXT,
    glProgramUniform2f,
    glProgramUniform2fEXT,
    glProgramUniform2fv,
    glProgramUniform2fvEXT,
    glProgramUniform2i,
    glProgramUniform2i64ARB,
    glProgramUniform2i64NV,
    glProgramUniform2i64vARB,
    glProgramUniform2i64vNV,
    glProgramUniform2iEXT,
    glProgramUniform2iv,
    glProgramUniform2ivEXT,
    glProgramUniform2ui,
    glProgramUniform2ui64ARB,
    glProgramUniform2ui64NV,
    glProgramUniform2ui64vARB,
    glProgramUniform2ui64vNV,
    glProgramUniform2uiEXT,
    glProgramUniform2uiv,
    glProgramUniform2uivEXT,
    glProgramUniform3d,
    glProgramUniform3dEXT,
    glProgramUniform3dv,
    glProgramUniform3dvEXT,
    glProgramUniform3f,
    glProgramUniform3fEXT,
    glProgramUniform3fv,
    glProgramUniform3fvEXT,
    glProgramUniform3i,
    glProgramUniform3i64ARB,
    glProgramUniform3i64NV,
    glProgramUniform3i64vARB,
    glProgramUniform3i64vNV,
    glProgramUniform3iEXT,
    glProgramUniform3iv,
    glProgramUniform3ivEXT,
    glProgramUniform3ui,
    glProgramUniform3ui64ARB,
    glProgramUniform3ui64NV,
    glProgramUniform3ui64vARB,
    glProgramUniform3ui64vNV,
    glProgramUniform3uiEXT,
    glProgramUniform3uiv,
    glProgramUniform3uivEXT,
    glProgramUniform4d,
    glProgramUniform4dEXT,
    glProgramUniform4dv,
    glProgramUniform4dvEXT,
    glProgramUniform4f,
    glProgramUniform4fEXT,
    glProgramUniform4fv,
    glProgramUniform4fvEXT,
    glProgramUniform4i,
    glProgramUniform4i64ARB,
    glProgramUniform4i64NV,
    glProgramUniform4i64vARB,
    glProgramUniform4i64vNV,
    glProgramUniform4iEXT,
    glProgramUniform4iv,
    glProgramUniform4ivEXT,
    glProgramUniform4ui,
    glProgramUniform4ui64ARB,
    glProgramUniform4ui64NV,
    glProgramUniform4ui64vARB,
    glProgramUniform4ui64vNV,
    glProgramUniform4uiEXT,
    glProgramUniform4uiv,
    glProgramUniform4uivEXT,
    glProgramUniformHandleui64ARB,
    glProgramUniformHandleui64NV,
    glProgramUniformHandleui64vARB,
    glProgramUniformHandleui64vNV,
    glProgramUniformMatrix2dv,
    glProgramUniformMatrix2dvEXT,
    glProgramUniformMatrix2fv,
    glProgramUniformMatrix2fvEXT,
    glProgramUniformMatrix2x3dv,
    glProgramUniformMatrix2x3dvEXT,
    glProgramUniformMatrix2x3fv,
    glProgramUniformMatrix2x3fvEXT,
    glProgramUniformMatrix2x4dv,
    glProgramUniformMatrix2x4dvEXT,
    glProgramUniformMatrix2x4fv,
    glProgramUniformMatrix2x4fvEXT,
    glProgramUniformMatrix3dv,
    glProgramUniformMatrix3dvEXT,
    glProgramUniformMatrix3fv,
    glProgramUniformMatrix3fvEXT,
    glProgramUniformMatrix3x2dv,
    glProgramUniformMatrix3x2dvEXT,
    glProgramUniformMatrix3x2fv,
    glProgramUniformMatrix3x2fvEXT,
    glProgramUniformMatrix3x4dv,
    glProgramUniformMatrix3x4dvEXT,
    glProgramUniformMatrix3x4fv,
    glProgramUniformMatrix3x4fvEXT,
    glProgramUniformMatrix4dv,
    glProgramUniformMatrix4dvEXT,
    glProgramUniformMatrix4fv,
    glProgramUniformMatrix4fvEXT,
    glProgramUniformMatrix4x2dv,
    glProgramUniformMatrix4x2dvEXT,
    glProgramUniformMatrix4x2fv,
    glProgramUniformMatrix4x2fvEXT,
    glProgramUniformMatrix4x3dv,
    glProgramUniformMatrix4x3dvEXT,
    glProgramUniformMatrix4x3fv,
    glProgramUniformMatrix4x3fvEXT,
    glProgramUniformui64NV,
    glProgramUniformui64vNV,
    glProgramVertexLimitNV,
    glProvokingVertex,
    glProvokingVertexEXT,
    glPushClientAttribDefaultEXT,
    glPushDebugGroup,
    glPushGroupMarkerEXT,
    glQueryCounter,
    glQueryMatrixxOES,
    glQueryObjectParameteruiAMD,
    glQueryResourceNV,
    glQueryResourceTagNV,
    glRasterPos2xOES,
    glRasterPos2xvOES,
    glRasterPos3xOES,
    glRasterPos3xvOES,
    glRasterPos4xOES,
    glRasterPos4xvOES,
    glRasterSamplesEXT,
    glReadBufferRegion,
    glReadInstrumentsSGIX,
    glReadnPixels,
    glReadnPixelsARB,
    glRectxOES,
    glRectxvOES,
    glReferencePlaneSGIX,
    glReleaseKeyedMutexWin32EXT,
    glReleaseShaderCompiler,
    glRenderGpuMaskNV,
    glRenderbufferStorage,
    glRenderbufferStorageEXT,
    glRenderbufferStorageMultisample,
    glRenderbufferStorageMultisampleAdvancedAMD,
    glRenderbufferStorageMultisampleCoverageNV,
    glRenderbufferStorageMultisampleEXT,
    glReplacementCodePointerSUN,
    glReplacementCodeubSUN,
    glReplacementCodeubvSUN,
    glReplacementCodeuiColor3fVertex3fSUN,
    glReplacementCodeuiColor3fVertex3fvSUN,
    glReplacementCodeuiColor4fNormal3fVertex3fSUN,
    glReplacementCodeuiColor4fNormal3fVertex3fvSUN,
    glReplacementCodeuiColor4ubVertex3fSUN,
    glReplacementCodeuiColor4ubVertex3fvSUN,
    glReplacementCodeuiNormal3fVertex3fSUN,
    glReplacementCodeuiNormal3fVertex3fvSUN,
    glReplacementCodeuiSUN,
    glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN,
    glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN,
    glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN,
    glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN,
    glReplacementCodeuiTexCoord2fVertex3fSUN,
    glReplacementCodeuiTexCoord2fVertex3fvSUN,
    glReplacementCodeuiVertex3fSUN,
    glReplacementCodeuiVertex3fvSUN,
    glReplacementCodeuivSUN,
    glReplacementCodeusSUN,
    glReplacementCodeusvSUN,
    glRequestResidentProgramsNV,
    glResetHistogram,
    glResetHistogramEXT,
    glResetMemoryObjectParameterNV,
    glResetMinmax,
    glResetMinmaxEXT,
    glResizeBuffersMESA,
    glResolveDepthValuesNV,
    glResumeTransformFeedback,
    glResumeTransformFeedbackNV,
    glRotatexOES,
    glSampleCoverage,
    glSampleCoverageARB,
    glSampleMapATI,
    glSampleMaskEXT,
    glSampleMaskIndexedNV,
    glSampleMaskSGIS,
    glSampleMaski,
    glSamplePatternEXT,
    glSamplePatternSGIS,
    glSamplerParameterIiv,
    glSamplerParameterIuiv,
    glSamplerParameterf,
    glSamplerParameterfv,
    glSamplerParameteri,
    glSamplerParameteriv,
    glScalexOES,
    glScissorArrayv,
    glScissorExclusiveArrayvNV,
    glScissorExclusiveNV,
    glScissorIndexed,
    glScissorIndexedv,
    glSecondaryColor3b,
    glSecondaryColor3bEXT,
    glSecondaryColor3bv,
    glSecondaryColor3bvEXT,
    glSecondaryColor3d,
    glSecondaryColor3dEXT,
    glSecondaryColor3dv,
    glSecondaryColor3dvEXT,
    glSecondaryColor3f,
    glSecondaryColor3fEXT,
    glSecondaryColor3fv,
    glSecondaryColor3fvEXT,
    glSecondaryColor3hNV,
    glSecondaryColor3hvNV,
    glSecondaryColor3i,
    glSecondaryColor3iEXT,
    glSecondaryColor3iv,
    glSecondaryColor3ivEXT,
    glSecondaryColor3s,
    glSecondaryColor3sEXT,
    glSecondaryColor3sv,
    glSecondaryColor3svEXT,
    glSecondaryColor3ub,
    glSecondaryColor3ubEXT,
    glSecondaryColor3ubv,
    glSecondaryColor3ubvEXT,
    glSecondaryColor3ui,
    glSecondaryColor3uiEXT,
    glSecondaryColor3uiv,
    glSecondaryColor3uivEXT,
    glSecondaryColor3us,
    glSecondaryColor3usEXT,
    glSecondaryColor3usv,
    glSecondaryColor3usvEXT,
    glSecondaryColorFormatNV,
    glSecondaryColorP3ui,
    glSecondaryColorP3uiv,
    glSecondaryColorPointer,
    glSecondaryColorPointerEXT,
    glSecondaryColorPointerListIBM,
    glSelectPerfMonitorCountersAMD,
    glSelectTextureCoordSetSGIS,
    glSelectTextureSGIS,
    glSemaphoreParameterui64vEXT,
    glSeparableFilter2D,
    glSeparableFilter2DEXT,
    glSetFenceAPPLE,
    glSetFenceNV,
    glSetFragmentShaderConstantATI,
    glSetInvariantEXT,
    glSetLocalConstantEXT,
    glSetMultisamplefvAMD,
    glShaderBinary,
    glShaderOp1EXT,
    glShaderOp2EXT,
    glShaderOp3EXT,
    glShaderSource,
    glShaderSourceARB,
    glShaderStorageBlockBinding,
    glShadingRateImageBarrierNV,
    glShadingRateImagePaletteNV,
    glShadingRateSampleOrderCustomNV,
    glShadingRateSampleOrderNV,
    glSharpenTexFuncSGIS,
    glSignalSemaphoreEXT,
    glSignalSemaphoreui64NVX,
    glSignalVkFenceNV,
    glSignalVkSemaphoreNV,
    glSpecializeShader,
    glSpecializeShaderARB,
    glSpriteParameterfSGIX,
    glSpriteParameterfvSGIX,
    glSpriteParameteriSGIX,
    glSpriteParameterivSGIX,
    glStartInstrumentsSGIX,
    glStateCaptureNV,
    glStencilClearTagEXT,
    glStencilFillPathInstancedNV,
    glStencilFillPathNV,
    glStencilFuncSeparate,
    glStencilFuncSeparateATI,
    glStencilMaskSeparate,
    glStencilOpSeparate,
    glStencilOpSeparateATI,
    glStencilOpValueAMD,
    glStencilStrokePathInstancedNV,
    glStencilStrokePathNV,
    glStencilThenCoverFillPathInstancedNV,
    glStencilThenCoverFillPathNV,
    glStencilThenCoverStrokePathInstancedNV,
    glStencilThenCoverStrokePathNV,
    glStopInstrumentsSGIX,
    glStringMarkerGREMEDY,
    glSubpixelPrecisionBiasNV,
    glSwizzleEXT,
    glSyncTextureINTEL,
    glTagSampleBufferSGIX,
    glTangent3bEXT,
    glTangent3bvEXT,
    glTangent3dEXT,
    glTangent3dvEXT,
    glTangent3fEXT,
    glTangent3fvEXT,
    glTangent3iEXT,
    glTangent3ivEXT,
    glTangent3sEXT,
    glTangent3svEXT,
    glTangentPointerEXT,
    glTbufferMask3DFX,
    glTessellationFactorAMD,
    glTessellationModeAMD,
    glTestFenceAPPLE,
    glTestFenceNV,
    glTestObjectAPPLE,
    glTexAttachMemoryNV,
    glTexBuffer,
    glTexBufferARB,
    glTexBufferEXT,
    glTexBufferRange,
    glTexBumpParameterfvATI,
    glTexBumpParameterivATI,
    glTexCoord1bOES,
    glTexCoord1bvOES,
    glTexCoord1hNV,
    glTexCoord1hvNV,
    glTexCoord1xOES,
    glTexCoord1xvOES,
    glTexCoord2bOES,
    glTexCoord2bvOES,
    glTexCoord2fColor3fVertex3fSUN,
    glTexCoord2fColor3fVertex3fvSUN,
    glTexCoord2fColor4fNormal3fVertex3fSUN,
    glTexCoord2fColor4fNormal3fVertex3fvSUN,
    glTexCoord2fColor4ubVertex3fSUN,
    glTexCoord2fColor4ubVertex3fvSUN,
    glTexCoord2fNormal3fVertex3fSUN,
    glTexCoord2fNormal3fVertex3fvSUN,
    glTexCoord2fVertex3fSUN,
    glTexCoord2fVertex3fvSUN,
    glTexCoord2hNV,
    glTexCoord2hvNV,
    glTexCoord2xOES,
    glTexCoord2xvOES,
    glTexCoord3bOES,
    glTexCoord3bvOES,
    glTexCoord3hNV,
    glTexCoord3hvNV,
    glTexCoord3xOES,
    glTexCoord3xvOES,
    glTexCoord4bOES,
    glTexCoord4bvOES,
    glTexCoord4fColor4fNormal3fVertex4fSUN,
    glTexCoord4fColor4fNormal3fVertex4fvSUN,
    glTexCoord4fVertex4fSUN,
    glTexCoord4fVertex4fvSUN,
    glTexCoord4hNV,
    glTexCoord4hvNV,
    glTexCoord4xOES,
    glTexCoord4xvOES,
    glTexCoordFormatNV,
    glTexCoordP1ui,
    glTexCoordP1uiv,
    glTexCoordP2ui,
    glTexCoordP2uiv,
    glTexCoordP3ui,
    glTexCoordP3uiv,
    glTexCoordP4ui,
    glTexCoordP4uiv,
    glTexCoordPointerEXT,
    glTexCoordPointerListIBM,
    glTexCoordPointervINTEL,
    glTexEnvxOES,
    glTexEnvxvOES,
    glTexFilterFuncSGIS,
    glTexGenxOES,
    glTexGenxvOES,
    glTexImage2DMultisample,
    glTexImage2DMultisampleCoverageNV,
    glTexImage3D,
    glTexImage3DEXT,
    glTexImage3DMultisample,
    glTexImage3DMultisampleCoverageNV,
    glTexImage4DSGIS,
    glTexPageCommitmentARB,
    glTexParameterIiv,
    glTexParameterIivEXT,
    glTexParameterIuiv,
    glTexParameterIuivEXT,
    glTexParameterxOES,
    glTexParameterxvOES,
    glTexRenderbufferNV,
    glTexStorage1D,
    glTexStorage2D,
    glTexStorage2DMultisample,
    glTexStorage3D,
    glTexStorage3DMultisample,
    glTexStorageMem1DEXT,
    glTexStorageMem2DEXT,
    glTexStorageMem2DMultisampleEXT,
    glTexStorageMem3DEXT,
    glTexStorageMem3DMultisampleEXT,
    glTexStorageSparseAMD,
    glTexSubImage1DEXT,
    glTexSubImage2DEXT,
    glTexSubImage3D,
    glTexSubImage3DEXT,
    glTexSubImage4DSGIS,
    glTextureAttachMemoryNV,
    glTextureBarrier,
    glTextureBarrierNV,
    glTextureBuffer,
    glTextureBufferEXT,
    glTextureBufferRange,
    glTextureBufferRangeEXT,
    glTextureColorMaskSGIS,
    glTextureImage1DEXT,
    glTextureImage2DEXT,
    glTextureImage2DMultisampleCoverageNV,
    glTextureImage2DMultisampleNV,
    glTextureImage3DEXT,
    glTextureImage3DMultisampleCoverageNV,
    glTextureImage3DMultisampleNV,
    glTextureLightEXT,
    glTextureMaterialEXT,
    glTextureNormalEXT,
    glTexturePageCommitmentEXT,
    glTextureParameterIiv,
    glTextureParameterIivEXT,
    glTextureParameterIuiv,
    glTextureParameterIuivEXT,
    glTextureParameterf,
    glTextureParameterfEXT,
    glTextureParameterfv,
    glTextureParameterfvEXT,
    glTextureParameteri,
    glTextureParameteriEXT,
    glTextureParameteriv,
    glTextureParameterivEXT,
    glTextureRangeAPPLE,
    glTextureRenderbufferEXT,
    glTextureStorage1D,
    glTextureStorage1DEXT,
    glTextureStorage2D,
    glTextureStorage2DEXT,
    glTextureStorage2DMultisample,
    glTextureStorage2DMultisampleEXT,
    glTextureStorage3D,
    glTextureStorage3DEXT,
    glTextureStorage3DMultisample,
    glTextureStorage3DMultisampleEXT,
    glTextureStorageMem1DEXT,
    glTextureStorageMem2DEXT,
    glTextureStorageMem2DMultisampleEXT,
    glTextureStorageMem3DEXT,
    glTextureStorageMem3DMultisampleEXT,
    glTextureStorageSparseAMD,
    glTextureSubImage1D,
    glTextureSubImage1DEXT,
    glTextureSubImage2D,
    glTextureSubImage2DEXT,
    glTextureSubImage3D,
    glTextureSubImage3DEXT,
    glTextureView,
    glTrackMatrixNV,
    glTransformFeedbackAttribsNV,
    glTransformFeedbackBufferBase,
    glTransformFeedbackBufferRange,
    glTransformFeedbackStreamAttribsNV,
    glTransformFeedbackVaryings,
    glTransformFeedbackVaryingsEXT,
    glTransformFeedbackVaryingsNV,
    glTransformPathNV,
    glTranslatexOES,
    glUniform1d,
    glUniform1dv,
    glUniform1f,
    glUniform1fARB,
    glUniform1fv,
    glUniform1fvARB,
    glUniform1i,
    glUniform1i64ARB,
    glUniform1i64NV,
    glUniform1i64vARB,
    glUniform1i64vNV,
    glUniform1iARB,
    glUniform1iv,
    glUniform1ivARB,
    glUniform1ui,
    glUniform1ui64ARB,
    glUniform1ui64NV,
    glUniform1ui64vARB,
    glUniform1ui64vNV,
    glUniform1uiEXT,
    glUniform1uiv,
    glUniform1uivEXT,
    glUniform2d,
    glUniform2dv,
    glUniform2f,
    glUniform2fARB,
    glUniform2fv,
    glUniform2fvARB,
    glUniform2i,
    glUniform2i64ARB,
    glUniform2i64NV,
    glUniform2i64vARB,
    glUniform2i64vNV,
    glUniform2iARB,
    glUniform2iv,
    glUniform2ivARB,
    glUniform2ui,
    glUniform2ui64ARB,
    glUniform2ui64NV,
    glUniform2ui64vARB,
    glUniform2ui64vNV,
    glUniform2uiEXT,
    glUniform2uiv,
    glUniform2uivEXT,
    glUniform3d,
    glUniform3dv,
    glUniform3f,
    glUniform3fARB,
    glUniform3fv,
    glUniform3fvARB,
    glUniform3i,
    glUniform3i64ARB,
    glUniform3i64NV,
    glUniform3i64vARB,
    glUniform3i64vNV,
    glUniform3iARB,
    glUniform3iv,
    glUniform3ivARB,
    glUniform3ui,
    glUniform3ui64ARB,
    glUniform3ui64NV,
    glUniform3ui64vARB,
    glUniform3ui64vNV,
    glUniform3uiEXT,
    glUniform3uiv,
    glUniform3uivEXT,
    glUniform4d,
    glUniform4dv,
    glUniform4f,
    glUniform4fARB,
    glUniform4fv,
    glUniform4fvARB,
    glUniform4i,
    glUniform4i64ARB,
    glUniform4i64NV,
    glUniform4i64vARB,
    glUniform4i64vNV,
    glUniform4iARB,
    glUniform4iv,
    glUniform4ivARB,
    glUniform4ui,
    glUniform4ui64ARB,
    glUniform4ui64NV,
    glUniform4ui64vARB,
    glUniform4ui64vNV,
    glUniform4uiEXT,
    glUniform4uiv,
    glUniform4uivEXT,
    glUniformBlockBinding,
    glUniformBufferEXT,
    glUniformHandleui64ARB,
    glUniformHandleui64NV,
    glUniformHandleui64vARB,
    glUniformHandleui64vNV,
    glUniformMatrix2dv,
    glUniformMatrix2fv,
    glUniformMatrix2fvARB,
    glUniformMatrix2x3dv,
    glUniformMatrix2x3fv,
    glUniformMatrix2x4dv,
    glUniformMatrix2x4fv,
    glUniformMatrix3dv,
    glUniformMatrix3fv,
    glUniformMatrix3fvARB,
    glUniformMatrix3x2dv,
    glUniformMatrix3x2fv,
    glUniformMatrix3x4dv,
    glUniformMatrix3x4fv,
    glUniformMatrix4dv,
    glUniformMatrix4fv,
    glUniformMatrix4fvARB,
    glUniformMatrix4x2dv,
    glUniformMatrix4x2fv,
    glUniformMatrix4x3dv,
    glUniformMatrix4x3fv,
    glUniformSubroutinesuiv,
    glUniformui64NV,
    glUniformui64vNV,
    glUnlockArraysEXT,
    glUnmapBuffer,
    glUnmapBufferARB,
    glUnmapNamedBuffer,
    glUnmapNamedBufferEXT,
    glUnmapObjectBufferATI,
    glUnmapTexture2DINTEL,
    glUpdateObjectBufferATI,
    glUploadGpuMaskNVX,
    glUseProgram,
    glUseProgramObjectARB,
    glUseProgramStages,
    glUseShaderProgramEXT,
    glVDPAUFiniNV,
    glVDPAUGetSurfaceivNV,
    glVDPAUInitNV,
    glVDPAUIsSurfaceNV,
    glVDPAUMapSurfacesNV,
    glVDPAURegisterOutputSurfaceNV,
    glVDPAURegisterVideoSurfaceNV,
    glVDPAURegisterVideoSurfaceWithPictureStructureNV,
    glVDPAUSurfaceAccessNV,
    glVDPAUUnmapSurfacesNV,
    glVDPAUUnregisterSurfaceNV,
    glValidateProgram,
    glValidateProgramARB,
    glValidateProgramPipeline,
    glVariantArrayObjectATI,
    glVariantPointerEXT,
    glVariantbvEXT,
    glVariantdvEXT,
    glVariantfvEXT,
    glVariantivEXT,
    glVariantsvEXT,
    glVariantubvEXT,
    glVariantuivEXT,
    glVariantusvEXT,
    glVertex2bOES,
    glVertex2bvOES,
    glVertex2hNV,
    glVertex2hvNV,
    glVertex2xOES,
    glVertex2xvOES,
    glVertex3bOES,
    glVertex3bvOES,
    glVertex3hNV,
    glVertex3hvNV,
    glVertex3xOES,
    glVertex3xvOES,
    glVertex4bOES,
    glVertex4bvOES,
    glVertex4hNV,
    glVertex4hvNV,
    glVertex4xOES,
    glVertex4xvOES,
    glVertexArrayAttribBinding,
    glVertexArrayAttribFormat,
    glVertexArrayAttribIFormat,
    glVertexArrayAttribLFormat,
    glVertexArrayBindVertexBufferEXT,
    glVertexArrayBindingDivisor,
    glVertexArrayColorOffsetEXT,
    glVertexArrayEdgeFlagOffsetEXT,
    glVertexArrayElementBuffer,
    glVertexArrayFogCoordOffsetEXT,
    glVertexArrayIndexOffsetEXT,
    glVertexArrayMultiTexCoordOffsetEXT,
    glVertexArrayNormalOffsetEXT,
    glVertexArrayParameteriAPPLE,
    glVertexArrayRangeAPPLE,
    glVertexArrayRangeNV,
    glVertexArraySecondaryColorOffsetEXT,
    glVertexArrayTexCoordOffsetEXT,
    glVertexArrayVertexAttribBindingEXT,
    glVertexArrayVertexAttribDivisorEXT,
    glVertexArrayVertexAttribFormatEXT,
    glVertexArrayVertexAttribIFormatEXT,
    glVertexArrayVertexAttribIOffsetEXT,
    glVertexArrayVertexAttribLFormatEXT,
    glVertexArrayVertexAttribLOffsetEXT,
    glVertexArrayVertexAttribOffsetEXT,
    glVertexArrayVertexBindingDivisorEXT,
    glVertexArrayVertexBuffer,
    glVertexArrayVertexBuffers,
    glVertexArrayVertexOffsetEXT,
    glVertexAttrib1d,
    glVertexAttrib1dARB,
    glVertexAttrib1dNV,
    glVertexAttrib1dv,
    glVertexAttrib1dvARB,
    glVertexAttrib1dvNV,
    glVertexAttrib1f,
    glVertexAttrib1fARB,
    glVertexAttrib1fNV,
    glVertexAttrib1fv,
    glVertexAttrib1fvARB,
    glVertexAttrib1fvNV,
    glVertexAttrib1hNV,
    glVertexAttrib1hvNV,
    glVertexAttrib1s,
    glVertexAttrib1sARB,
    glVertexAttrib1sNV,
    glVertexAttrib1sv,
    glVertexAttrib1svARB,
    glVertexAttrib1svNV,
    glVertexAttrib2d,
    glVertexAttrib2dARB,
    glVertexAttrib2dNV,
    glVertexAttrib2dv,
    glVertexAttrib2dvARB,
    glVertexAttrib2dvNV,
    glVertexAttrib2f,
    glVertexAttrib2fARB,
    glVertexAttrib2fNV,
    glVertexAttrib2fv,
    glVertexAttrib2fvARB,
    glVertexAttrib2fvNV,
    glVertexAttrib2hNV,
    glVertexAttrib2hvNV,
    glVertexAttrib2s,
    glVertexAttrib2sARB,
    glVertexAttrib2sNV,
    glVertexAttrib2sv,
    glVertexAttrib2svARB,
    glVertexAttrib2svNV,
    glVertexAttrib3d,
    glVertexAttrib3dARB,
    glVertexAttrib3dNV,
    glVertexAttrib3dv,
    glVertexAttrib3dvARB,
    glVertexAttrib3dvNV,
    glVertexAttrib3f,
    glVertexAttrib3fARB,
    glVertexAttrib3fNV,
    glVertexAttrib3fv,
    glVertexAttrib3fvARB,
    glVertexAttrib3fvNV,
    glVertexAttrib3hNV,
    glVertexAttrib3hvNV,
    glVertexAttrib3s,
    glVertexAttrib3sARB,
    glVertexAttrib3sNV,
    glVertexAttrib3sv,
    glVertexAttrib3svARB,
    glVertexAttrib3svNV,
    glVertexAttrib4Nbv,
    glVertexAttrib4NbvARB,
    glVertexAttrib4Niv,
    glVertexAttrib4NivARB,
    glVertexAttrib4Nsv,
    glVertexAttrib4NsvARB,
    glVertexAttrib4Nub,
    glVertexAttrib4NubARB,
    glVertexAttrib4Nubv,
    glVertexAttrib4NubvARB,
    glVertexAttrib4Nuiv,
    glVertexAttrib4NuivARB,
    glVertexAttrib4Nusv,
    glVertexAttrib4NusvARB,
    glVertexAttrib4bv,
    glVertexAttrib4bvARB,
    glVertexAttrib4d,
    glVertexAttrib4dARB,
    glVertexAttrib4dNV,
    glVertexAttrib4dv,
    glVertexAttrib4dvARB,
    glVertexAttrib4dvNV,
    glVertexAttrib4f,
    glVertexAttrib4fARB,
    glVertexAttrib4fNV,
    glVertexAttrib4fv,
    glVertexAttrib4fvARB,
    glVertexAttrib4fvNV,
    glVertexAttrib4hNV,
    glVertexAttrib4hvNV,
    glVertexAttrib4iv,
    glVertexAttrib4ivARB,
    glVertexAttrib4s,
    glVertexAttrib4sARB,
    glVertexAttrib4sNV,
    glVertexAttrib4sv,
    glVertexAttrib4svARB,
    glVertexAttrib4svNV,
    glVertexAttrib4ubNV,
    glVertexAttrib4ubv,
    glVertexAttrib4ubvARB,
    glVertexAttrib4ubvNV,
    glVertexAttrib4uiv,
    glVertexAttrib4uivARB,
    glVertexAttrib4usv,
    glVertexAttrib4usvARB,
    glVertexAttribArrayObjectATI,
    glVertexAttribBinding,
    glVertexAttribDivisor,
    glVertexAttribDivisorARB,
    glVertexAttribFormat,
    glVertexAttribFormatNV,
    glVertexAttribI1i,
    glVertexAttribI1iEXT,
    glVertexAttribI1iv,
    glVertexAttribI1ivEXT,
    glVertexAttribI1ui,
    glVertexAttribI1uiEXT,
    glVertexAttribI1uiv,
    glVertexAttribI1uivEXT,
    glVertexAttribI2i,
    glVertexAttribI2iEXT,
    glVertexAttribI2iv,
    glVertexAttribI2ivEXT,
    glVertexAttribI2ui,
    glVertexAttribI2uiEXT,
    glVertexAttribI2uiv,
    glVertexAttribI2uivEXT,
    glVertexAttribI3i,
    glVertexAttribI3iEXT,
    glVertexAttribI3iv,
    glVertexAttribI3ivEXT,
    glVertexAttribI3ui,
    glVertexAttribI3uiEXT,
    glVertexAttribI3uiv,
    glVertexAttribI3uivEXT,
    glVertexAttribI4bv,
    glVertexAttribI4bvEXT,
    glVertexAttribI4i,
    glVertexAttribI4iEXT,
    glVertexAttribI4iv,
    glVertexAttribI4ivEXT,
    glVertexAttribI4sv,
    glVertexAttribI4svEXT,
    glVertexAttribI4ubv,
    glVertexAttribI4ubvEXT,
    glVertexAttribI4ui,
    glVertexAttribI4uiEXT,
    glVertexAttribI4uiv,
    glVertexAttribI4uivEXT,
    glVertexAttribI4usv,
    glVertexAttribI4usvEXT,
    glVertexAttribIFormat,
    glVertexAttribIFormatNV,
    glVertexAttribIPointer,
    glVertexAttribIPointerEXT,
    glVertexAttribL1d,
    glVertexAttribL1dEXT,
    glVertexAttribL1dv,
    glVertexAttribL1dvEXT,
    glVertexAttribL1i64NV,
    glVertexAttribL1i64vNV,
    glVertexAttribL1ui64ARB,
    glVertexAttribL1ui64NV,
    glVertexAttribL1ui64vARB,
    glVertexAttribL1ui64vNV,
    glVertexAttribL2d,
    glVertexAttribL2dEXT,
    glVertexAttribL2dv,
    glVertexAttribL2dvEXT,
    glVertexAttribL2i64NV,
    glVertexAttribL2i64vNV,
    glVertexAttribL2ui64NV,
    glVertexAttribL2ui64vNV,
    glVertexAttribL3d,
    glVertexAttribL3dEXT,
    glVertexAttribL3dv,
    glVertexAttribL3dvEXT,
    glVertexAttribL3i64NV,
    glVertexAttribL3i64vNV,
    glVertexAttribL3ui64NV,
    glVertexAttribL3ui64vNV,
    glVertexAttribL4d,
    glVertexAttribL4dEXT,
    glVertexAttribL4dv,
    glVertexAttribL4dvEXT,
    glVertexAttribL4i64NV,
    glVertexAttribL4i64vNV,
    glVertexAttribL4ui64NV,
    glVertexAttribL4ui64vNV,
    glVertexAttribLFormat,
    glVertexAttribLFormatNV,
    glVertexAttribLPointer,
    glVertexAttribLPointerEXT,
    glVertexAttribP1ui,
    glVertexAttribP1uiv,
    glVertexAttribP2ui,
    glVertexAttribP2uiv,
    glVertexAttribP3ui,
    glVertexAttribP3uiv,
    glVertexAttribP4ui,
    glVertexAttribP4uiv,
    glVertexAttribParameteriAMD,
    glVertexAttribPointer,
    glVertexAttribPointerARB,
    glVertexAttribPointerNV,
    glVertexAttribs1dvNV,
    glVertexAttribs1fvNV,
    glVertexAttribs1hvNV,
    glVertexAttribs1svNV,
    glVertexAttribs2dvNV,
    glVertexAttribs2fvNV,
    glVertexAttribs2hvNV,
    glVertexAttribs2svNV,
    glVertexAttribs3dvNV,
    glVertexAttribs3fvNV,
    glVertexAttribs3hvNV,
    glVertexAttribs3svNV,
    glVertexAttribs4dvNV,
    glVertexAttribs4fvNV,
    glVertexAttribs4hvNV,
    glVertexAttribs4svNV,
    glVertexAttribs4ubvNV,
    glVertexBindingDivisor,
    glVertexBlendARB,
    glVertexBlendEnvfATI,
    glVertexBlendEnviATI,
    glVertexFormatNV,
    glVertexP2ui,
    glVertexP2uiv,
    glVertexP3ui,
    glVertexP3uiv,
    glVertexP4ui,
    glVertexP4uiv,
    glVertexPointerEXT,
    glVertexPointerListIBM,
    glVertexPointervINTEL,
    glVertexStream1dATI,
    glVertexStream1dvATI,
    glVertexStream1fATI,
    glVertexStream1fvATI,
    glVertexStream1iATI,
    glVertexStream1ivATI,
    glVertexStream1sATI,
    glVertexStream1svATI,
    glVertexStream2dATI,
    glVertexStream2dvATI,
    glVertexStream2fATI,
    glVertexStream2fvATI,
    glVertexStream2iATI,
    glVertexStream2ivATI,
    glVertexStream2sATI,
    glVertexStream2svATI,
    glVertexStream3dATI,
    glVertexStream3dvATI,
    glVertexStream3fATI,
    glVertexStream3fvATI,
    glVertexStream3iATI,
    glVertexStream3ivATI,
    glVertexStream3sATI,
    glVertexStream3svATI,
    glVertexStream4dATI,
    glVertexStream4dvATI,
    glVertexStream4fATI,
    glVertexStream4fvATI,
    glVertexStream4iATI,
    glVertexStream4ivATI,
    glVertexStream4sATI,
    glVertexStream4svATI,
    glVertexWeightPointerEXT,
    glVertexWeightfEXT,
    glVertexWeightfvEXT,
    glVertexWeighthNV,
    glVertexWeighthvNV,
    glVideoCaptureNV,
    glVideoCaptureStreamParameterdvNV,
    glVideoCaptureStreamParameterfvNV,
    glVideoCaptureStreamParameterivNV,
    glViewportArrayv,
    glViewportIndexedf,
    glViewportIndexedfv,
    glViewportPositionWScaleNV,
    glViewportSwizzleNV,
    glWaitSemaphoreEXT,
    glWaitSemaphoreui64NVX,
    glWaitSync,
    glWaitVkSemaphoreNV,
    glWeightPathsNV,
    glWeightPointerARB,
    glWeightbvARB,
    glWeightdvARB,
    glWeightfvARB,
    glWeightivARB,
    glWeightsvARB,
    glWeightubvARB,
    glWeightuivARB,
    glWeightusvARB,
    glWindowPos2d,
    glWindowPos2dARB,
    glWindowPos2dMESA,
    glWindowPos2dv,
    glWindowPos2dvARB,
    glWindowPos2dvMESA,
    glWindowPos2f,
    glWindowPos2fARB,
    glWindowPos2fMESA,
    glWindowPos2fv,
    glWindowPos2fvARB,
    glWindowPos2fvMESA,
    glWindowPos2i,
    glWindowPos2iARB,
    glWindowPos2iMESA,
    glWindowPos2iv,
    glWindowPos2ivARB,
    glWindowPos2ivMESA,
    glWindowPos2s,
    glWindowPos2sARB,
    glWindowPos2sMESA,
    glWindowPos2sv,
    glWindowPos2svARB,
    glWindowPos2svMESA,
    glWindowPos3d,
    glWindowPos3dARB,
    glWindowPos3dMESA,
    glWindowPos3dv,
    glWindowPos3dvARB,
    glWindowPos3dvMESA,
    glWindowPos3f,
    glWindowPos3fARB,
    glWindowPos3fMESA,
    glWindowPos3fv,
    glWindowPos3fvARB,
    glWindowPos3fvMESA,
    glWindowPos3i,
    glWindowPos3iARB,
    glWindowPos3iMESA,
    glWindowPos3iv,
    glWindowPos3ivARB,
    glWindowPos3ivMESA,
    glWindowPos3s,
    glWindowPos3sARB,
    glWindowPos3sMESA,
    glWindowPos3sv,
    glWindowPos3svARB,
    glWindowPos3svMESA,
    glWindowPos4dMESA,
    glWindowPos4dvMESA,
    glWindowPos4fMESA,
    glWindowPos4fvMESA,
    glWindowPos4iMESA,
    glWindowPos4ivMESA,
    glWindowPos4sMESA,
    glWindowPos4svMESA,
    glWindowRectanglesEXT,
    glWriteMaskEXT,
    wglAllocateMemoryNV,
    wglBindTexImageARB,
    wglChoosePixelFormatARB,
    wglCreateContextAttribsARB,
    wglCreatePbufferARB,
    wglDestroyPbufferARB,
    wglFreeMemoryNV,
    wglGetCurrentReadDCARB,
    wglGetExtensionsStringARB,
    wglGetExtensionsStringEXT,
    wglGetPbufferDCARB,
    wglGetPixelFormatAttribfvARB,
    wglGetPixelFormatAttribivARB,
    wglGetSwapIntervalEXT,
    wglMakeContextCurrentARB,
    wglQueryCurrentRendererIntegerWINE,
    wglQueryCurrentRendererStringWINE,
    wglQueryPbufferARB,
    wglQueryRendererIntegerWINE,
    wglQueryRendererStringWINE,
    wglReleasePbufferDCARB,
    wglReleaseTexImageARB,
    wglSetPbufferAttribARB,
    wglSetPixelFormatWINE,
    wglSwapIntervalEXT,
};